@chartts/gl 0.1.3

package/dist/chunk-Q4JAQOV3.cjs

@@ -0,0 +1,3516 @@
+'use strict';
+
+// src/engine/math.ts
+function vec3(x = 0, y = 0, z = 0) {
+  return new Float32Array([x, y, z]);
+}
+function mat4() {
+  const m = new Float32Array(16);
+  m[0] = 1;
+  m[5] = 1;
+  m[10] = 1;
+  m[15] = 1;
+  return m;
+}
+function vec3Add(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  return out;
+}
+function vec3Scale(out, a, s) {
+  out[0] = a[0] * s;
+  out[1] = a[1] * s;
+  out[2] = a[2] * s;
+  return out;
+}
+function vec3Length(a) {
+  return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+}
+function vec3Normalize(out, a) {
+  const len = vec3Length(a);
+  if (len > 0) {
+    const inv = 1 / len;
+    out[0] = a[0] * inv;
+    out[1] = a[1] * inv;
+    out[2] = a[2] * inv;
+  }
+  return out;
+}
+function vec3Cross(out, a, b) {
+  const ax = a[0], ay = a[1], az = a[2];
+  const bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function mat4Identity(out) {
+  out.fill(0);
+  out[0] = 1;
+  out[5] = 1;
+  out[10] = 1;
+  out[15] = 1;
+  return out;
+}
+function mat4Multiply(out, a, b) {
+  const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[4];
+  b1 = b[5];
+  b2 = b[6];
+  b3 = b[7];
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[8];
+  b1 = b[9];
+  b2 = b[10];
+  b3 = b[11];
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[12];
+  b1 = b[13];
+  b2 = b[14];
+  b3 = b[15];
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  return out;
+}
+function mat4Perspective(out, fovY, aspect, near, far) {
+  const f = 1 / Math.tan(fovY / 2);
+  out.fill(0);
+  out[0] = f / aspect;
+  out[5] = f;
+  out[10] = (far + near) / (near - far);
+  out[11] = -1;
+  out[14] = 2 * far * near / (near - far);
+  return out;
+}
+function mat4Ortho(out, left, right, bottom, top, near, far) {
+  const lr = 1 / (left - right);
+  const bt = 1 / (bottom - top);
+  const nf = 1 / (near - far);
+  out.fill(0);
+  out[0] = -2 * lr;
+  out[5] = -2 * bt;
+  out[10] = 2 * nf;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf;
+  out[15] = 1;
+  return out;
+}
+function mat4LookAt(out, eye, center, up) {
+  const zx = eye[0] - center[0];
+  const zy = eye[1] - center[1];
+  const zz = eye[2] - center[2];
+  let len = 1 / Math.sqrt(zx * zx + zy * zy + zz * zz);
+  const z0 = zx * len, z1 = zy * len, z2 = zz * len;
+  const xx = up[1] * z2 - up[2] * z1;
+  const xy = up[2] * z0 - up[0] * z2;
+  const xz = up[0] * z1 - up[1] * z0;
+  len = Math.sqrt(xx * xx + xy * xy + xz * xz);
+  const x0 = len ? xx / len : 0, x1 = len ? xy / len : 0, x2 = len ? xz / len : 0;
+  const y0 = z1 * x2 - z2 * x1;
+  const y1 = z2 * x0 - z0 * x2;
+  const y2 = z0 * x1 - z1 * x0;
+  out[0] = x0;
+  out[1] = y0;
+  out[2] = z0;
+  out[3] = 0;
+  out[4] = x1;
+  out[5] = y1;
+  out[6] = z1;
+  out[7] = 0;
+  out[8] = x2;
+  out[9] = y2;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = -(x0 * eye[0] + x1 * eye[1] + x2 * eye[2]);
+  out[13] = -(y0 * eye[0] + y1 * eye[1] + y2 * eye[2]);
+  out[14] = -(z0 * eye[0] + z1 * eye[1] + z2 * eye[2]);
+  out[15] = 1;
+  return out;
+}
+function mat4Invert(out, a) {
+  const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  const b00 = a00 * a11 - a01 * a10;
+  const b01 = a00 * a12 - a02 * a10;
+  const b02 = a00 * a13 - a03 * a10;
+  const b03 = a01 * a12 - a02 * a11;
+  const b04 = a01 * a13 - a03 * a11;
+  const b05 = a02 * a13 - a03 * a12;
+  const b06 = a20 * a31 - a21 * a30;
+  const b07 = a20 * a32 - a22 * a30;
+  const b08 = a20 * a33 - a23 * a30;
+  const b09 = a21 * a32 - a22 * a31;
+  const b10 = a21 * a33 - a23 * a31;
+  const b11 = a22 * a33 - a23 * a32;
+  let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) return null;
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+function mat3NormalFromMat4(out, a) {
+  const a00 = a[0], a01 = a[1], a02 = a[2];
+  const a10 = a[4], a11 = a[5], a12 = a[6];
+  const a20 = a[8], a21 = a[9], a22 = a[10];
+  const b01 = a22 * a11 - a12 * a21;
+  const b11 = -a22 * a10 + a12 * a20;
+  const b21 = a21 * a10 - a11 * a20;
+  let det = a00 * b01 + a01 * b11 + a02 * b21;
+  if (!det) return out;
+  det = 1 / det;
+  out[0] = b01 * det;
+  out[1] = (-a22 * a01 + a02 * a21) * det;
+  out[2] = (a12 * a01 - a02 * a11) * det;
+  out[3] = b11 * det;
+  out[4] = (a22 * a00 - a02 * a20) * det;
+  out[5] = (-a12 * a00 + a02 * a10) * det;
+  out[6] = b21 * det;
+  out[7] = (-a21 * a00 + a01 * a20) * det;
+  out[8] = (a11 * a00 - a01 * a10) * det;
+  return out;
+}
+function toRad(deg) {
+  return deg * Math.PI / 180;
+}
+
+// src/engine/camera.ts
+function createCamera(width, height, opts = {}) {
+  const state = {
+    position: vec3(...opts.position ?? [5, 5, 5]),
+    target: vec3(...opts.target ?? [0, 0, 0]),
+    up: vec3(...opts.up ?? [0, 1, 0]),
+    fov: toRad(opts.fov ?? 45),
+    near: opts.near ?? 0.1,
+    far: opts.far ?? 1e3,
+    aspect: width / height,
+    ortho: opts.ortho ?? false,
+    projectionMatrix: mat4(),
+    viewMatrix: mat4(),
+    projViewMatrix: mat4(),
+    invProjViewMatrix: mat4()
+  };
+  updateCamera(state, width, height);
+  return state;
+}
+function updateCamera(state, width, height) {
+  state.aspect = width / height;
+  if (state.ortho) {
+    const halfH = 5;
+    const halfW = halfH * state.aspect;
+    mat4Ortho(state.projectionMatrix, -halfW, halfW, -halfH, halfH, state.near, state.far);
+  } else {
+    mat4Perspective(state.projectionMatrix, state.fov, state.aspect, state.near, state.far);
+  }
+  mat4LookAt(state.viewMatrix, state.position, state.target, state.up);
+  mat4Multiply(state.projViewMatrix, state.projectionMatrix, state.viewMatrix);
+  mat4Invert(state.invProjViewMatrix, state.projViewMatrix);
+}
+function setCameraPosition(state, pos) {
+  state.position[0] = pos[0];
+  state.position[1] = pos[1];
+  state.position[2] = pos[2];
+}
+function setCameraTarget(state, target) {
+  state.target[0] = target[0];
+  state.target[1] = target[1];
+  state.target[2] = target[2];
+}
+function projectToScreen(worldPos, projView, width, height) {
+  const m = projView;
+  const x = worldPos[0], y = worldPos[1], z = worldPos[2];
+  const w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  if (Math.abs(w) < 1e-10) return null;
+  const ndcX = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  const ndcY = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  const ndcZ = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return {
+    x: (ndcX * 0.5 + 0.5) * width,
+    y: (1 - (ndcY * 0.5 + 0.5)) * height,
+    z: ndcZ
+  };
+}
+
+// src/engine/orbit-controls.ts
+function cartesianToSpherical(pos, target) {
+  const dx = pos[0] - target[0];
+  const dy = pos[1] - target[1];
+  const dz = pos[2] - target[2];
+  const radius = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  const theta = Math.atan2(dx, dz);
+  const phi = Math.acos(Math.max(-1, Math.min(1, dy / (radius || 1))));
+  return { theta, phi, radius };
+}
+function sphericalToCartesian(theta, phi, radius, target, out) {
+  out[0] = target[0] + radius * Math.sin(phi) * Math.sin(theta);
+  out[1] = target[1] + radius * Math.cos(phi);
+  out[2] = target[2] + radius * Math.sin(phi) * Math.cos(theta);
+}
+function createOrbitControls(canvas, camera, _width, _height, config = {}) {
+  const cfg = {
+    enableRotate: config.enableRotate ?? true,
+    enableZoom: config.enableZoom ?? true,
+    enablePan: config.enablePan ?? true,
+    damping: config.damping ?? 0.1,
+    autoRotate: config.autoRotate ?? false,
+    autoRotateSpeed: config.autoRotateSpeed ?? 1,
+    minDistance: config.minDistance ?? 0.5,
+    maxDistance: config.maxDistance ?? 500,
+    minPolarAngle: config.minPolarAngle ?? 0.01,
+    maxPolarAngle: config.maxPolarAngle ?? Math.PI - 0.01
+  };
+  const { theta, phi, radius } = cartesianToSpherical(camera.position, camera.target);
+  const state = {
+    theta,
+    phi,
+    radius,
+    target: vec3(camera.target[0], camera.target[1], camera.target[2]),
+    dragging: false,
+    panning: false,
+    lastX: 0,
+    lastY: 0,
+    velocityTheta: 0,
+    velocityPhi: 0,
+    config: cfg,
+    dispose: () => {
+    }
+  };
+  const onMouseDown = (e) => {
+    if (e.button === 0 && cfg.enableRotate) {
+      state.dragging = true;
+      state.lastX = e.clientX;
+      state.lastY = e.clientY;
+      state.velocityTheta = 0;
+      state.velocityPhi = 0;
+    } else if (e.button === 2 && cfg.enablePan) {
+      state.panning = true;
+      state.lastX = e.clientX;
+      state.lastY = e.clientY;
+      e.preventDefault();
+    }
+  };
+  const onMouseMove = (e) => {
+    if (state.dragging) {
+      const dx = e.clientX - state.lastX;
+      const dy = e.clientY - state.lastY;
+      state.velocityTheta = -dx * 5e-3;
+      state.velocityPhi = -dy * 5e-3;
+      state.theta += state.velocityTheta;
+      state.phi = Math.max(cfg.minPolarAngle, Math.min(cfg.maxPolarAngle, state.phi + state.velocityPhi));
+      state.lastX = e.clientX;
+      state.lastY = e.clientY;
+    } else if (state.panning) {
+      const dx = e.clientX - state.lastX;
+      const dy = e.clientY - state.lastY;
+      const panSpeed = state.radius * 2e-3;
+      const forward = vec3(
+        camera.target[0] - camera.position[0],
+        camera.target[1] - camera.position[1],
+        camera.target[2] - camera.position[2]
+      );
+      const right = vec3(0, 0, 0);
+      vec3Cross(right, forward, camera.up);
+      vec3Normalize(right, right);
+      const up = vec3(0, 0, 0);
+      vec3Cross(up, right, forward);
+      vec3Normalize(up, up);
+      const panX = vec3Scale(vec3(0, 0, 0), right, -dx * panSpeed);
+      const panY = vec3Scale(vec3(0, 0, 0), up, dy * panSpeed);
+      vec3Add(state.target, state.target, panX);
+      vec3Add(state.target, state.target, panY);
+      state.lastX = e.clientX;
+      state.lastY = e.clientY;
+    }
+  };
+  const onMouseUp = () => {
+    state.dragging = false;
+    state.panning = false;
+  };
+  const onWheel = (e) => {
+    if (!cfg.enableZoom) return;
+    e.preventDefault();
+    const factor = e.deltaY > 0 ? 1.1 : 0.9;
+    state.radius = Math.max(cfg.minDistance, Math.min(cfg.maxDistance, state.radius * factor));
+  };
+  const onContextMenu = (e) => e.preventDefault();
+  let touchStartDist = 0;
+  let touchStartRadius = 0;
+  const onTouchStart = (e) => {
+    if (e.touches.length === 1 && cfg.enableRotate) {
+      state.dragging = true;
+      state.lastX = e.touches[0].clientX;
+      state.lastY = e.touches[0].clientY;
+      state.velocityTheta = 0;
+      state.velocityPhi = 0;
+    } else if (e.touches.length === 2 && cfg.enableZoom) {
+      const dx = e.touches[0].clientX - e.touches[1].clientX;
+      const dy = e.touches[0].clientY - e.touches[1].clientY;
+      touchStartDist = Math.sqrt(dx * dx + dy * dy);
+      touchStartRadius = state.radius;
+    }
+  };
+  const onTouchMove = (e) => {
+    e.preventDefault();
+    if (e.touches.length === 1 && state.dragging) {
+      const dx = e.touches[0].clientX - state.lastX;
+      const dy = e.touches[0].clientY - state.lastY;
+      state.velocityTheta = -dx * 5e-3;
+      state.velocityPhi = -dy * 5e-3;
+      state.theta += state.velocityTheta;
+      state.phi = Math.max(cfg.minPolarAngle, Math.min(cfg.maxPolarAngle, state.phi + state.velocityPhi));
+      state.lastX = e.touches[0].clientX;
+      state.lastY = e.touches[0].clientY;
+    } else if (e.touches.length === 2 && cfg.enableZoom) {
+      const dx = e.touches[0].clientX - e.touches[1].clientX;
+      const dy = e.touches[0].clientY - e.touches[1].clientY;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      state.radius = Math.max(cfg.minDistance, Math.min(cfg.maxDistance, touchStartRadius * (touchStartDist / dist)));
+    }
+  };
+  const onTouchEnd = () => {
+    state.dragging = false;
+  };
+  canvas.addEventListener("mousedown", onMouseDown);
+  canvas.addEventListener("mousemove", onMouseMove);
+  canvas.addEventListener("mouseup", onMouseUp);
+  canvas.addEventListener("mouseleave", onMouseUp);
+  canvas.addEventListener("wheel", onWheel, { passive: false });
+  canvas.addEventListener("contextmenu", onContextMenu);
+  canvas.addEventListener("touchstart", onTouchStart, { passive: true });
+  canvas.addEventListener("touchmove", onTouchMove, { passive: false });
+  canvas.addEventListener("touchend", onTouchEnd);
+  state.dispose = () => {
+    canvas.removeEventListener("mousedown", onMouseDown);
+    canvas.removeEventListener("mousemove", onMouseMove);
+    canvas.removeEventListener("mouseup", onMouseUp);
+    canvas.removeEventListener("mouseleave", onMouseUp);
+    canvas.removeEventListener("wheel", onWheel);
+    canvas.removeEventListener("contextmenu", onContextMenu);
+    canvas.removeEventListener("touchstart", onTouchStart);
+    canvas.removeEventListener("touchmove", onTouchMove);
+    canvas.removeEventListener("touchend", onTouchEnd);
+  };
+  return state;
+}
+function updateOrbitControls(orbit, camera, width, height) {
+  let changed = false;
+  const cfg = orbit.config;
+  if (cfg.autoRotate && !orbit.dragging) {
+    orbit.theta += cfg.autoRotateSpeed * 1e-3;
+    changed = true;
+  }
+  if (!orbit.dragging) {
+    if (Math.abs(orbit.velocityTheta) > 1e-4 || Math.abs(orbit.velocityPhi) > 1e-4) {
+      orbit.theta += orbit.velocityTheta * cfg.damping;
+      orbit.phi += orbit.velocityPhi * cfg.damping;
+      orbit.phi = Math.max(cfg.minPolarAngle, Math.min(cfg.maxPolarAngle, orbit.phi));
+      orbit.velocityTheta *= 1 - cfg.damping;
+      orbit.velocityPhi *= 1 - cfg.damping;
+      changed = true;
+    } else {
+      orbit.velocityTheta = 0;
+      orbit.velocityPhi = 0;
+    }
+  } else {
+    changed = true;
+  }
+  if (orbit.panning) changed = true;
+  const newPos = vec3(0, 0, 0);
+  sphericalToCartesian(orbit.theta, orbit.phi, orbit.radius, orbit.target, newPos);
+  setCameraPosition(camera, newPos);
+  setCameraTarget(camera, orbit.target);
+  updateCamera(camera, width, height);
+  return changed;
+}
+
+// src/engine/shader.ts
+function compileShader(gl, type, source) {
+  const shader = gl.createShader(type);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const info = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`[chartts/gl] Shader compile error: ${info}`);
+  }
+  return shader;
+}
+function createShaderProgram(gl, vertSrc, fragSrc, uniformNames, attributeNames) {
+  const vert = compileShader(gl, gl.VERTEX_SHADER, vertSrc);
+  const frag = compileShader(gl, gl.FRAGMENT_SHADER, fragSrc);
+  const program = gl.createProgram();
+  gl.attachShader(program, vert);
+  gl.attachShader(program, frag);
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const info = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`[chartts/gl] Program link error: ${info}`);
+  }
+  const uniforms = {};
+  for (const name of uniformNames) {
+    const loc = gl.getUniformLocation(program, name);
+    if (loc) uniforms[name] = loc;
+  }
+  const attributes = {};
+  for (const name of attributeNames) {
+    attributes[name] = gl.getAttribLocation(program, name);
+  }
+  return {
+    program,
+    uniforms,
+    attributes,
+    use() {
+      gl.useProgram(program);
+    },
+    setMat4(name, value) {
+      const loc = uniforms[name];
+      if (loc) gl.uniformMatrix4fv(loc, false, value);
+    },
+    setMat3(name, value) {
+      const loc = uniforms[name];
+      if (loc) gl.uniformMatrix3fv(loc, false, value);
+    },
+    setVec2(name, x, y) {
+      const loc = uniforms[name];
+      if (loc) gl.uniform2f(loc, x, y);
+    },
+    setVec3(name, x, y, z) {
+      const loc = uniforms[name];
+      if (loc) gl.uniform3f(loc, x, y, z);
+    },
+    setVec4(name, x, y, z, w) {
+      const loc = uniforms[name];
+      if (loc) gl.uniform4f(loc, x, y, z, w);
+    },
+    setFloat(name, value) {
+      const loc = uniforms[name];
+      if (loc) gl.uniform1f(loc, value);
+    },
+    setInt(name, value) {
+      const loc = uniforms[name];
+      if (loc) gl.uniform1i(loc, value);
+    },
+    destroy() {
+      gl.deleteShader(vert);
+      gl.deleteShader(frag);
+      gl.deleteProgram(program);
+    }
+  };
+}
+
+// src/engine/renderer.ts
+function createGLRenderer(container) {
+  const pixelRatio = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+  const glCanvas = document.createElement("canvas");
+  glCanvas.style.position = "absolute";
+  glCanvas.style.top = "0";
+  glCanvas.style.left = "0";
+  glCanvas.style.width = "100%";
+  glCanvas.style.height = "100%";
+  const overlayCanvas = document.createElement("canvas");
+  overlayCanvas.style.position = "absolute";
+  overlayCanvas.style.top = "0";
+  overlayCanvas.style.left = "0";
+  overlayCanvas.style.width = "100%";
+  overlayCanvas.style.height = "100%";
+  overlayCanvas.style.pointerEvents = "none";
+  const containerPos = getComputedStyle(container).position;
+  if (containerPos === "static") container.style.position = "relative";
+  container.appendChild(glCanvas);
+  container.appendChild(overlayCanvas);
+  const gl = glCanvas.getContext("webgl", {
+    antialias: true,
+    alpha: false,
+    premultipliedAlpha: false,
+    preserveDrawingBuffer: false,
+    depth: true,
+    stencil: false
+  });
+  if (!gl) throw new Error("[chartts/gl] WebGL not supported");
+  const ctx2d = overlayCanvas.getContext("2d");
+  gl.enable(gl.DEPTH_TEST);
+  gl.depthFunc(gl.LEQUAL);
+  gl.enable(gl.CULL_FACE);
+  gl.cullFace(gl.BACK);
+  gl.enable(gl.BLEND);
+  gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+  const width = container.clientWidth;
+  const height = container.clientHeight;
+  const renderer = {
+    gl,
+    ctx2d,
+    glCanvas,
+    overlayCanvas,
+    width,
+    height,
+    pixelRatio,
+    programs: /* @__PURE__ */ new Map(),
+    registerProgram(name, vert, frag, uniforms, attributes) {
+      const existing = this.programs.get(name);
+      if (existing) return existing;
+      const prog = createShaderProgram(gl, vert, frag, uniforms, attributes);
+      this.programs.set(name, prog);
+      return prog;
+    },
+    getProgram(name) {
+      return this.programs.get(name);
+    },
+    resize(w, h) {
+      this.width = w;
+      this.height = h;
+      const pw = Math.round(w * pixelRatio);
+      const ph = Math.round(h * pixelRatio);
+      glCanvas.width = pw;
+      glCanvas.height = ph;
+      overlayCanvas.width = pw;
+      overlayCanvas.height = ph;
+      gl.viewport(0, 0, pw, ph);
+      ctx2d.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+    },
+    beginFrame() {
+      ctx2d.clearRect(0, 0, this.width, this.height);
+    },
+    endFrame() {
+      gl.flush();
+    },
+    clear(r, g, b, a) {
+      gl.clearColor(r, g, b, a);
+      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+    },
+    destroy() {
+      for (const prog of this.programs.values()) {
+        prog.destroy();
+      }
+      this.programs.clear();
+      glCanvas.remove();
+      overlayCanvas.remove();
+    }
+  };
+  renderer.resize(width, height);
+  return renderer;
+}
+
+// src/engine/lighting.ts
+function defaultLightConfig() {
+  return {
+    ambient: [0.35, 0.33, 0.4],
+    diffuseDirection: [0.6, 0.9, 0.4],
+    diffuseColor: [1, 0.97, 0.95],
+    specularColor: [1, 0.98, 0.96],
+    shininess: 48
+  };
+}
+function setLightUniforms(program, light, cameraPos) {
+  program.setVec3("u_ambientColor", light.ambient[0], light.ambient[1], light.ambient[2]);
+  const [dx, dy, dz] = light.diffuseDirection;
+  const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+  program.setVec3("u_lightDir", dx / len, dy / len, dz / len);
+  program.setVec3("u_diffuseColor", light.diffuseColor[0], light.diffuseColor[1], light.diffuseColor[2]);
+  program.setVec3("u_specularColor", light.specularColor[0], light.specularColor[1], light.specularColor[2]);
+  program.setFloat("u_shininess", light.shininess);
+  program.setVec3("u_cameraPos", cameraPos[0], cameraPos[1], cameraPos[2]);
+}
+
+// src/engine/picking.ts
+function createPickingSystem(gl, width, height, pixelRatio) {
+  const pw = Math.round(width * pixelRatio);
+  const ph = Math.round(height * pixelRatio);
+  const framebuffer = gl.createFramebuffer();
+  const texture = gl.createTexture();
+  const depthBuffer = gl.createRenderbuffer();
+  function setupFBO(w, h) {
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindRenderbuffer(gl.RENDERBUFFER, depthBuffer);
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, w, h);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depthBuffer);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  }
+  setupFBO(pw, ph);
+  let currentWidth = pw;
+  let currentHeight = ph;
+  const pixel = new Uint8Array(4);
+  return {
+    begin() {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+      gl.viewport(0, 0, currentWidth, currentHeight);
+      gl.clearColor(0, 0, 0, 0);
+      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+      gl.disable(gl.BLEND);
+    },
+    end() {
+      gl.enable(gl.BLEND);
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      gl.viewport(0, 0, currentWidth, currentHeight);
+    },
+    pick(x, y) {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+      const px = Math.round(x * pixelRatio);
+      const py = currentHeight - Math.round(y * pixelRatio);
+      gl.readPixels(px, py, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      if (pixel[3] === 0) return -1;
+      return pixel[0] + pixel[1] * 256 + pixel[2] * 65536;
+    },
+    idToColor(id) {
+      return [
+        (id & 255) / 255,
+        (id >> 8 & 255) / 255,
+        (id >> 16 & 255) / 255
+      ];
+    },
+    resize(w, h) {
+      currentWidth = Math.round(w * pixelRatio);
+      currentHeight = Math.round(h * pixelRatio);
+      setupFBO(currentWidth, currentHeight);
+    },
+    destroy() {
+      gl.deleteFramebuffer(framebuffer);
+      gl.deleteTexture(texture);
+      gl.deleteRenderbuffer(depthBuffer);
+    }
+  };
+}
+
+// src/engine/buffer.ts
+function createVertexBuffer(gl, data, usage = gl.STATIC_DRAW) {
+  const buffer = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.bufferData(gl.ARRAY_BUFFER, data, usage);
+  return {
+    buffer,
+    count: data.length,
+    bind() {
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    },
+    update(newData, u = usage) {
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+      gl.bufferData(gl.ARRAY_BUFFER, newData, u);
+      this.count = newData.length;
+    },
+    destroy() {
+      gl.deleteBuffer(buffer);
+    }
+  };
+}
+function createIndexBuffer(gl, data, usage = gl.STATIC_DRAW) {
+  const buffer = gl.createBuffer();
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, usage);
+  return {
+    buffer,
+    count: data.length,
+    bind() {
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+    },
+    update(newData, u = usage) {
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, newData, u);
+      this.count = newData.length;
+    },
+    destroy() {
+      gl.deleteBuffer(buffer);
+    }
+  };
+}
+function createVertexLayout(attribs) {
+  let offset = 0;
+  const attributes = [];
+  for (const a of attribs) {
+    attributes.push({ location: a.location, size: a.size, offset: offset * 4 });
+    offset += a.size;
+  }
+  return { stride: offset * 4, attributes };
+}
+function applyVertexLayout(gl, layout) {
+  for (const attr of layout.attributes) {
+    gl.enableVertexAttribArray(attr.location);
+    gl.vertexAttribPointer(attr.location, attr.size, gl.FLOAT, false, layout.stride, attr.offset);
+  }
+}
+function disableVertexLayout(gl, layout) {
+  for (const attr of layout.attributes) {
+    gl.disableVertexAttribArray(attr.location);
+  }
+}
+
+// src/engine/grid3d.ts
+var GRID_VERT = (
+  /* glsl */
+  `
+precision highp float;
+attribute vec3 a_position;
+attribute vec3 a_color;
+uniform mat4 u_projView;
+varying vec3 v_color;
+void main() {
+  gl_Position = u_projView * vec4(a_position, 1.0);
+  v_color = a_color;
+}
+`
+);
+var GRID_FRAG = (
+  /* glsl */
+  `
+precision highp float;
+uniform float u_opacity;
+varying vec3 v_color;
+void main() {
+  gl_FragColor = vec4(v_color, u_opacity);
+}
+`
+);
+function createGrid3D(renderer) {
+  const gl = renderer.gl;
+  renderer.registerProgram(
+    "grid3d",
+    GRID_VERT,
+    GRID_FRAG,
+    ["u_projView", "u_opacity"],
+    ["a_position", "a_color"]
+  );
+  let vbo = null;
+  let lineCount = 0;
+  return {
+    update(bounds) {
+      const { minX, maxX, minZ, maxZ, y } = bounds;
+      const rangeX = maxX - minX || 1;
+      const rangeZ = maxZ - minZ || 1;
+      const maxRange = Math.max(rangeX, rangeZ);
+      const rawStep = maxRange / 10;
+      const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
+      const normalized = rawStep / magnitude;
+      const step = normalized < 2 ? magnitude : normalized < 5 ? 2 * magnitude : 5 * magnitude;
+      const gridColor = [0.18, 0.2, 0.28];
+      const axisColor = [0.3, 0.35, 0.5];
+      const verts = [];
+      const pad = step;
+      const gMinX = Math.floor((minX - pad) / step) * step;
+      const gMaxX = Math.ceil((maxX + pad) / step) * step;
+      const gMinZ = Math.floor((minZ - pad) / step) * step;
+      const gMaxZ = Math.ceil((maxZ + pad) / step) * step;
+      for (let x = gMinX; x <= gMaxX + step * 0.01; x += step) {
+        const isAxis = Math.abs(x) < step * 0.01;
+        const c = isAxis ? axisColor : gridColor;
+        verts.push(x, y, gMinZ, c[0], c[1], c[2]);
+        verts.push(x, y, gMaxZ, c[0], c[1], c[2]);
+      }
+      for (let z = gMinZ; z <= gMaxZ + step * 0.01; z += step) {
+        const isAxis = Math.abs(z) < step * 0.01;
+        const c = isAxis ? axisColor : gridColor;
+        verts.push(gMinX, y, z, c[0], c[1], c[2]);
+        verts.push(gMaxX, y, z, c[0], c[1], c[2]);
+      }
+      const data = new Float32Array(verts);
+      if (vbo) vbo.update(data);
+      else vbo = createVertexBuffer(gl, data, gl.DYNAMIC_DRAW);
+      lineCount = verts.length / 6 / 2;
+    },
+    render(camera, opacity) {
+      if (!vbo || lineCount === 0) return;
+      const prog = renderer.getProgram("grid3d");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      prog.setFloat("u_opacity", opacity * 0.4);
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 }
+      ]);
+      applyVertexLayout(gl, layout);
+      gl.disable(gl.DEPTH_TEST);
+      gl.drawArrays(gl.LINES, 0, lineCount * 2);
+      gl.enable(gl.DEPTH_TEST);
+      disableVertexLayout(gl, layout);
+    },
+    destroy() {
+      vbo?.destroy();
+      vbo = null;
+    }
+  };
+}
+
+// src/types.ts
+var DEFAULT_GL_THEME = {
+  background: [0.06, 0.065, 0.1],
+  colors: [
+    "#6c9eff",
+    "#5eead4",
+    "#fbbf24",
+    "#f472b6",
+    "#a78bfa",
+    "#34d399",
+    "#fb923c",
+    "#38bdf8"
+  ],
+  textColor: "#b8c4d0",
+  gridColor: "#1e2536",
+  fontFamily: "system-ui, -apple-system, sans-serif",
+  fontSize: 12
+};
+var LIGHT_GL_THEME = {
+  background: [0.95, 0.96, 0.98],
+  colors: [
+    "#4f7df5",
+    "#10b981",
+    "#f59e0b",
+    "#ec4899",
+    "#8b5cf6",
+    "#14b8a6",
+    "#f97316",
+    "#0ea5e9"
+  ],
+  textColor: "#374151",
+  gridColor: "#d1d9e6",
+  fontFamily: "system-ui, -apple-system, sans-serif",
+  fontSize: 12
+};
+function hexToRGB(hex) {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.substring(0, 2), 16) / 255,
+    parseInt(h.substring(2, 4), 16) / 255,
+    parseInt(h.substring(4, 6), 16) / 255
+  ];
+}
+function resolveTheme(theme) {
+  if (!theme || theme === "dark") return DEFAULT_GL_THEME;
+  if (theme === "light") return LIGHT_GL_THEME;
+  return theme;
+}
+
+// src/api/create-gl.ts
+function computeDataBounds(data) {
+  let minX = Infinity, maxX = -Infinity;
+  let minY = Infinity, maxY = -Infinity;
+  let minZ = Infinity, maxZ = -Infinity;
+  if (data.grid && data.grid.length > 0) {
+    const rows = data.grid.length, cols = data.grid[0].length;
+    for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+      const y = data.grid[r][c];
+      const x = c / (cols - 1 || 1) * 10 - 5;
+      const z = r / (rows - 1 || 1) * 10 - 5;
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+      if (z < minZ) minZ = z;
+      if (z > maxZ) maxZ = z;
+    }
+  }
+  for (const s of data.series) {
+    const s3d = s;
+    if (s3d.x) for (const v of s3d.x) {
+      if (v < minX) minX = v;
+      if (v > maxX) maxX = v;
+    }
+    if (s3d.y) for (const v of s3d.y) {
+      if (v < minY) minY = v;
+      if (v > maxY) maxY = v;
+    }
+    if (s3d.z) for (const v of s3d.z) {
+      if (v < minZ) minZ = v;
+      if (v > maxZ) maxZ = v;
+    }
+    if (s3d.values) for (const v of s3d.values) {
+      if (v < minY) minY = v;
+      if (v > maxY) maxY = v;
+    }
+  }
+  if (minX === Infinity) {
+    minX = -5;
+    maxX = 5;
+  }
+  if (minY === Infinity) {
+    minY = 0;
+    maxY = 5;
+  }
+  if (minZ === Infinity) {
+    minZ = -5;
+    maxZ = 5;
+  }
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const cz = (minZ + maxZ) / 2;
+  const extentX = maxX - minX || 1;
+  const extentY = maxY - minY || 1;
+  const extentZ = maxZ - minZ || 1;
+  const maxExtent = Math.max(extentX, extentY, extentZ);
+  return { center: [cx, cy, cz], maxExtent, minX, maxX, minY, maxY, minZ, maxZ };
+}
+function createGLChart(container, plugin, data, options = {}) {
+  const el = typeof container === "string" ? document.querySelector(container) : container;
+  if (!el) throw new Error(`[chartts/gl] Container not found: ${container}`);
+  const renderer = createGLRenderer(el);
+  const { width, height } = renderer;
+  const theme = resolveTheme(options.theme);
+  const is2D = plugin.type.endsWith("-gl");
+  let cameraOpts = options.camera;
+  if (!is2D && !cameraOpts?.position) {
+    const bounds = computeDataBounds(data);
+    const [cx, cy, cz] = bounds.center;
+    const dist = Math.max(bounds.maxExtent * 1.6, 5);
+    cameraOpts = {
+      ...cameraOpts,
+      position: [cx + dist * 0.7, cy + dist * 0.5, cz + dist * 0.7],
+      target: [cx, cy, cz]
+    };
+  }
+  const camera = createCamera(width, height, cameraOpts);
+  let orbit = null;
+  if (options.orbit !== false) {
+    const orbitConfig = typeof options.orbit === "object" ? options.orbit : {};
+    orbit = createOrbitControls(renderer.glCanvas, camera, width, height, orbitConfig);
+  }
+  const lightConfig = {
+    ...defaultLightConfig(),
+    ...options.light || {}
+  };
+  const picking = createPickingSystem(renderer.gl, width, height, renderer.pixelRatio);
+  const ctx = {
+    renderer,
+    camera,
+    orbit,
+    picking,
+    width,
+    height,
+    data,
+    options,
+    theme,
+    animationProgress: options.animate !== false ? 0 : 1
+  };
+  plugin.prepare(ctx);
+  let grid = null;
+  if (!is2D && options["grid"] !== false) {
+    grid = createGrid3D(renderer);
+    const bounds = computeDataBounds(data);
+    grid.update({
+      minX: bounds.minX,
+      maxX: bounds.maxX,
+      minZ: bounds.minZ,
+      maxZ: bounds.maxZ,
+      y: bounds.minY
+    });
+  }
+  let animating = options.animate !== false;
+  const animDuration = options.animationDuration ?? 800;
+  let animStart = 0;
+  let rafId = 0;
+  let disposed = false;
+  let loopRunning = false;
+  let dirty = true;
+  let tooltipEl = null;
+  if (options.tooltip !== false) {
+    tooltipEl = document.createElement("div");
+    tooltipEl.style.cssText = `
+      position: absolute; pointer-events: none; display: none;
+      background: rgba(0,0,0,0.85); color: #fff; padding: 6px 10px;
+      border-radius: 4px; font-size: 12px; font-family: ${theme.fontFamily};
+      z-index: 10; white-space: nowrap;
+    `;
+    el.appendChild(tooltipEl);
+  }
+  function drawFrame() {
+    const bg = theme.background;
+    renderer.beginFrame();
+    renderer.clear(bg[0], bg[1], bg[2], 1);
+    const meshProg = renderer.getProgram("mesh");
+    if (meshProg) {
+      meshProg.use();
+      setLightUniforms(meshProg, lightConfig, camera.position);
+    }
+    if (grid) grid.render(camera, ctx.animationProgress);
+    plugin.render(ctx);
+    if (plugin.renderOverlay) {
+      plugin.renderOverlay(ctx, renderer.ctx2d);
+    }
+    renderer.endFrame();
+  }
+  function renderFrame(time) {
+    if (disposed) {
+      loopRunning = false;
+      return;
+    }
+    if (animating) {
+      if (animStart === 0) animStart = time;
+      const elapsed = time - animStart;
+      ctx.animationProgress = Math.min(1, elapsed / animDuration);
+      if (ctx.animationProgress >= 1) animating = false;
+      dirty = true;
+    }
+    if (orbit) {
+      const orbitChanged = updateOrbitControls(orbit, camera, ctx.width, ctx.height);
+      if (orbitChanged) dirty = true;
+    }
+    const needsLoop = plugin.needsLoop?.(ctx) ?? false;
+    if (needsLoop) dirty = true;
+    if (dirty) {
+      drawFrame();
+      dirty = false;
+    }
+    const keepLooping = animating || needsLoop || orbit != null && (orbit.dragging || orbit.panning || Math.abs(orbit.velocityTheta) > 1e-4 || Math.abs(orbit.velocityPhi) > 1e-4 || orbit.config.autoRotate);
+    if (keepLooping) {
+      rafId = requestAnimationFrame(renderFrame);
+    } else {
+      loopRunning = false;
+    }
+  }
+  function ensureLoop() {
+    if (disposed) return;
+    dirty = true;
+    if (!loopRunning) {
+      loopRunning = true;
+      rafId = requestAnimationFrame(renderFrame);
+    }
+  }
+  const onInteraction = () => ensureLoop();
+  renderer.glCanvas.addEventListener("mousedown", onInteraction);
+  renderer.glCanvas.addEventListener("mousemove", onInteraction);
+  renderer.glCanvas.addEventListener("wheel", onInteraction, { passive: true });
+  renderer.glCanvas.addEventListener("touchstart", onInteraction, { passive: true });
+  renderer.glCanvas.addEventListener("touchmove", onInteraction, { passive: true });
+  const onMouseMove = (e) => {
+    const rect = renderer.glCanvas.getBoundingClientRect();
+    const x = e.clientX - rect.left;
+    const y = e.clientY - rect.top;
+    const hit = plugin.hitTest(ctx, x, y);
+    if (tooltipEl) {
+      if (hit) {
+        tooltipEl.style.display = "block";
+        tooltipEl.style.left = `${x + 12}px`;
+        tooltipEl.style.top = `${y - 12}px`;
+        tooltipEl.textContent = `${hit.seriesName}: ${hit.value.toFixed(2)}`;
+      } else {
+        tooltipEl.style.display = "none";
+      }
+    }
+  };
+  renderer.glCanvas.addEventListener("mousemove", onMouseMove);
+  loopRunning = true;
+  rafId = requestAnimationFrame(renderFrame);
+  const resizeObserver = new ResizeObserver(() => {
+    if (disposed) return;
+    const w = el.clientWidth;
+    const h = el.clientHeight;
+    if (w === 0 || h === 0) return;
+    renderer.resize(w, h);
+    ctx.width = w;
+    ctx.height = h;
+    updateCamera(camera, w, h);
+    picking.resize(w, h);
+    ensureLoop();
+  });
+  resizeObserver.observe(el);
+  return {
+    update(newData) {
+      ctx.data = newData;
+      plugin.prepare(ctx);
+      if (grid) {
+        const bounds = computeDataBounds(newData);
+        grid.update({ minX: bounds.minX, maxX: bounds.maxX, minZ: bounds.minZ, maxZ: bounds.maxZ, y: bounds.minY });
+      }
+      if (options.animate !== false) {
+        animating = true;
+        animStart = 0;
+        ctx.animationProgress = 0;
+      }
+      ensureLoop();
+    },
+    setOption(opts) {
+      Object.assign(ctx.options, opts);
+      if (opts.theme) {
+        const newTheme = resolveTheme(opts.theme);
+        Object.assign(ctx.theme, newTheme);
+      }
+      plugin.prepare(ctx);
+      ensureLoop();
+    },
+    setCameraPosition(pos) {
+      camera.position[0] = pos[0];
+      camera.position[1] = pos[1];
+      camera.position[2] = pos[2];
+      updateCamera(camera, ctx.width, ctx.height);
+      ensureLoop();
+    },
+    setCameraTarget(target) {
+      camera.target[0] = target[0];
+      camera.target[1] = target[1];
+      camera.target[2] = target[2];
+      if (orbit) {
+        orbit.target[0] = target[0];
+        orbit.target[1] = target[1];
+        orbit.target[2] = target[2];
+      }
+      updateCamera(camera, ctx.width, ctx.height);
+      ensureLoop();
+    },
+    resize() {
+      const w = el.clientWidth;
+      const h = el.clientHeight;
+      renderer.resize(w, h);
+      ctx.width = w;
+      ctx.height = h;
+      updateCamera(camera, w, h);
+      picking.resize(w, h);
+      ensureLoop();
+    },
+    getDataAtPoint(x, y) {
+      return plugin.hitTest(ctx, x, y);
+    },
+    destroy() {
+      disposed = true;
+      loopRunning = false;
+      cancelAnimationFrame(rafId);
+      resizeObserver.disconnect();
+      renderer.glCanvas.removeEventListener("mousedown", onInteraction);
+      renderer.glCanvas.removeEventListener("mousemove", onInteraction);
+      renderer.glCanvas.removeEventListener("wheel", onInteraction);
+      renderer.glCanvas.removeEventListener("touchstart", onInteraction);
+      renderer.glCanvas.removeEventListener("touchmove", onInteraction);
+      renderer.glCanvas.removeEventListener("mousemove", onMouseMove);
+      if (tooltipEl) tooltipEl.remove();
+      grid?.destroy();
+      orbit?.dispose();
+      plugin.dispose(renderer.gl);
+      picking.destroy();
+      renderer.destroy();
+    }
+  };
+}
+
+// src/shaders/common.glsl.ts
+var PROJECTION_UNIFORMS = (
+  /* glsl */
+  `
+uniform mat4 u_projView;
+uniform mat4 u_model;
+`
+);
+var NORMAL_UNIFORMS = (
+  /* glsl */
+  `
+uniform mat3 u_normalMatrix;
+`
+);
+var PHONG_UNIFORMS = (
+  /* glsl */
+  `
+uniform vec3 u_ambientColor;
+uniform vec3 u_lightDir;
+uniform vec3 u_diffuseColor;
+uniform vec3 u_specularColor;
+uniform float u_shininess;
+uniform vec3 u_cameraPos;
+`
+);
+var PHONG_FUNCTION = (
+  /* glsl */
+  `
+vec3 phongLighting(vec3 normal, vec3 fragPos, vec3 baseColor) {
+  vec3 N = normalize(normal);
+  vec3 L = normalize(u_lightDir);
+  vec3 V = normalize(u_cameraPos - fragPos);
+  vec3 H = normalize(L + V);
+
+  // Hemisphere ambient - warm sky, cool ground
+  float hemi = dot(N, vec3(0.0, 1.0, 0.0)) * 0.5 + 0.5;
+  vec3 skyAmbient = u_ambientColor * vec3(1.1, 1.05, 1.2);
+  vec3 groundAmbient = u_ambientColor * vec3(0.6, 0.55, 0.7);
+  vec3 ambient = mix(groundAmbient, skyAmbient, hemi) * baseColor;
+
+  // Smooth wrapped diffuse for softer light falloff
+  float NdotL = dot(N, L);
+  float diff = max(NdotL * 0.5 + 0.5, 0.0);
+  diff = diff * diff;
+  vec3 diffuse = u_diffuseColor * diff * baseColor;
+
+  // Fill light from below-side for depth
+  vec3 fillDir = normalize(vec3(-0.4, -0.3, -0.6));
+  float fillDiff = max(dot(N, fillDir) * 0.5 + 0.5, 0.0);
+  vec3 fill = baseColor * fillDiff * 0.15;
+
+  // Blinn-Phong specular with smooth falloff
+  float spec = pow(max(dot(N, H), 0.0), u_shininess);
+  vec3 specular = u_specularColor * spec * 0.7;
+
+  // Rim/fresnel glow - bright edges like subsurface scatter
+  float rim = 1.0 - max(dot(V, N), 0.0);
+  rim = pow(rim, 3.0);
+  vec3 rimColor = mix(baseColor, vec3(1.0), 0.5);
+  vec3 rimLight = rimColor * rim * 0.35;
+
+  vec3 result = ambient + diffuse + fill + specular + rimLight;
+
+  // Slight saturation boost
+  float lum = dot(result, vec3(0.299, 0.587, 0.114));
+  result = mix(vec3(lum), result, 1.12);
+
+  return clamp(result, 0.0, 1.0);
+}
+`
+);
+
+// src/shaders/point.vert.ts
+var POINT_VERT = (
+  /* glsl */
+  `
+precision highp float;
+
+${PROJECTION_UNIFORMS}
+
+attribute vec3 a_position;
+attribute vec3 a_color;
+attribute float a_size;
+
+uniform float u_pixelRatio;
+uniform float u_sizeAttenuation;
+
+varying vec3 v_color;
+
+void main() {
+  vec4 worldPos = u_model * vec4(a_position, 1.0);
+  vec4 mvPos = u_projView * worldPos;
+  gl_Position = mvPos;
+
+  float attenuation = u_sizeAttenuation > 0.0
+    ? u_sizeAttenuation / max(mvPos.z, 0.1)
+    : 1.0;
+  gl_PointSize = a_size * u_pixelRatio * attenuation;
+  v_color = a_color;
+}
+`
+);
+var POINT_VERT_UNIFORMS = [
+  "u_projView",
+  "u_model",
+  "u_pixelRatio",
+  "u_sizeAttenuation"
+];
+var POINT_VERT_ATTRIBUTES = [
+  "a_position",
+  "a_color",
+  "a_size"
+];
+
+// src/shaders/point.frag.ts
+var POINT_FRAG = (
+  /* glsl */
+  `
+precision highp float;
+
+uniform float u_opacity;
+
+varying vec3 v_color;
+
+void main() {
+  vec2 coord = gl_PointCoord - vec2(0.5);
+  float dist = length(coord);
+  if (dist > 0.5) discard;
+
+  // Solid core with soft edge
+  float coreAlpha = 1.0 - smoothstep(0.3, 0.42, dist);
+  // Outer glow halo
+  float glowAlpha = (1.0 - smoothstep(0.2, 0.5, dist)) * 0.4;
+  float alpha = max(coreAlpha, glowAlpha);
+
+  // Brighten center for a glossy look
+  vec3 color = v_color + vec3(0.15) * (1.0 - smoothstep(0.0, 0.2, dist));
+
+  gl_FragColor = vec4(color, alpha * u_opacity);
+}
+`
+);
+var POINT_FRAG_UNIFORMS = ["u_opacity"];
+
+// src/charts/scatter3d/scatter3d-type.ts
+function createScatter3DPlugin() {
+  let vbo = null;
+  let pointCount = 0;
+  let seriesData = [];
+  const modelMatrix = mat4();
+  return {
+    type: "scatter3d",
+    prepare(ctx) {
+      const { renderer, data, options, theme } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "point3d",
+        POINT_VERT,
+        POINT_FRAG,
+        [...POINT_VERT_UNIFORMS, ...POINT_FRAG_UNIFORMS],
+        POINT_VERT_ATTRIBUTES
+      );
+      const floatsPerVertex = 7;
+      seriesData = [];
+      let totalPoints = 0;
+      for (const s of series) totalPoints += s.values.length;
+      const vertices = new Float32Array(totalPoints * floatsPerVertex);
+      let offset = 0;
+      const defaultSize = options.pointSize ?? 8;
+      for (let si = 0; si < series.length; si++) {
+        const s = series[si];
+        const color = hexToRGB(s.color ?? theme.colors[si % theme.colors.length]);
+        const size = s.size ?? defaultSize;
+        for (let di = 0; di < s.values.length; di++) {
+          const x = s.x?.[di] ?? di;
+          const y = s.values[di];
+          const z = s.z?.[di] ?? 0;
+          vertices[offset++] = x;
+          vertices[offset++] = y;
+          vertices[offset++] = z;
+          vertices[offset++] = color[0];
+          vertices[offset++] = color[1];
+          vertices[offset++] = color[2];
+          vertices[offset++] = size;
+          seriesData.push({ seriesIndex: si, dataIndex: di, x, y, z, value: y, name: s.name });
+        }
+      }
+      if (vbo) vbo.update(vertices);
+      else vbo = createVertexBuffer(gl, vertices, gl.DYNAMIC_DRAW);
+      pointCount = totalPoints;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("point3d");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      prog.setMat4("u_model", modelMatrix);
+      prog.setFloat("u_pixelRatio", renderer.pixelRatio);
+      prog.setFloat("u_sizeAttenuation", 50);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (!vbo || pointCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 },
+        { location: prog.attributes["a_size"], size: 1 }
+      ]);
+      applyVertexLayout(gl, layout);
+      gl.drawArrays(gl.POINTS, 0, pointCount);
+      disableVertexLayout(gl, layout);
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height } = ctx;
+      let closest = null;
+      let closestDist = 20;
+      for (const d of seriesData) {
+        const screen = projectToScreen(
+          new Float32Array([d.x, d.y, d.z]),
+          camera.projViewMatrix,
+          width,
+          height
+        );
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dx = screen.x - x;
+        const dy = screen.y - y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: d.seriesIndex, dataIndex: d.dataIndex, value: d.value, x: d.x, y: d.y, z: d.z, seriesName: d.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      seriesData = [];
+    }
+  };
+}
+
+// src/shaders/mesh.vert.ts
+var MESH_VERT = (
+  /* glsl */
+  `
+precision highp float;
+
+${PROJECTION_UNIFORMS}
+${NORMAL_UNIFORMS}
+
+attribute vec3 a_position;
+attribute vec3 a_normal;
+attribute vec3 a_color;
+
+varying vec3 v_normal;
+varying vec3 v_fragPos;
+varying vec3 v_color;
+
+void main() {
+  vec4 worldPos = u_model * vec4(a_position, 1.0);
+  v_fragPos = worldPos.xyz;
+  v_normal = u_normalMatrix * a_normal;
+  v_color = a_color;
+  gl_Position = u_projView * worldPos;
+}
+`
+);
+var MESH_VERT_UNIFORMS = [
+  "u_projView",
+  "u_model",
+  "u_normalMatrix"
+];
+var MESH_VERT_ATTRIBUTES = [
+  "a_position",
+  "a_normal",
+  "a_color"
+];
+
+// src/shaders/mesh.frag.ts
+var MESH_FRAG = (
+  /* glsl */
+  `
+precision highp float;
+
+${PHONG_UNIFORMS}
+
+uniform float u_opacity;
+
+varying vec3 v_normal;
+varying vec3 v_fragPos;
+varying vec3 v_color;
+
+${PHONG_FUNCTION}
+
+void main() {
+  vec3 lit = phongLighting(v_normal, v_fragPos, v_color);
+  gl_FragColor = vec4(lit, u_opacity);
+}
+`
+);
+var MESH_FRAG_UNIFORMS = [
+  "u_ambientColor",
+  "u_lightDir",
+  "u_diffuseColor",
+  "u_specularColor",
+  "u_shininess",
+  "u_cameraPos",
+  "u_opacity"
+];
+
+// src/charts/bar3d/bar3d-type.ts
+function buildCuboid(cx, cy, cz, sx, sy, sz, r, g, b, verts, indices, baseVertex) {
+  const hx = sx * 0.5, hy = sy * 0.5, hz = sz * 0.5;
+  const faces = [
+    { p: [[1, 1, 1], [1, -1, 1], [1, -1, -1], [1, 1, -1]], n: [1, 0, 0] },
+    { p: [[-1, 1, -1], [-1, -1, -1], [-1, -1, 1], [-1, 1, 1]], n: [-1, 0, 0] },
+    { p: [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]], n: [0, 1, 0] },
+    { p: [[-1, -1, 1], [-1, -1, -1], [1, -1, -1], [1, -1, 1]], n: [0, -1, 0] },
+    { p: [[-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, 1, 1]], n: [0, 0, 1] },
+    { p: [[1, 1, -1], [1, -1, -1], [-1, -1, -1], [-1, 1, -1]], n: [0, 0, -1] }
+  ];
+  let vi = baseVertex;
+  for (const face of faces) {
+    for (const p of face.p) {
+      verts.push(cx + p[0] * hx, cy + p[1] * hy, cz + p[2] * hz, face.n[0], face.n[1], face.n[2], r, g, b);
+    }
+    indices.push(vi, vi + 1, vi + 2, vi, vi + 2, vi + 3);
+    vi += 4;
+  }
+}
+function createBar3DPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let indexType = 0;
+  const modelMatrix = mat4();
+  const normalMatrix = new Float32Array(9);
+  let barData = [];
+  return {
+    type: "bar3d",
+    prepare(ctx) {
+      const { renderer, data, options, theme } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "mesh",
+        MESH_VERT,
+        MESH_FRAG,
+        [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
+        MESH_VERT_ATTRIBUTES
+      );
+      const verts = [];
+      const indices = [];
+      barData = [];
+      let baseVertex = 0;
+      const barWidth = options["barWidth"] ?? 0.6;
+      const barDepth = options["barDepth"] ?? 0.6;
+      for (let si = 0; si < series.length; si++) {
+        const s = series[si];
+        const color = hexToRGB(s.color ?? theme.colors[si % theme.colors.length]);
+        for (let di = 0; di < s.values.length; di++) {
+          const x = s.x?.[di] ?? di;
+          const z = s.z?.[di] ?? si;
+          const height = s.values[di];
+          const cy = height * 0.5;
+          buildCuboid(x, cy, z, barWidth, Math.max(0.01, height), barDepth, color[0], color[1], color[2], verts, indices, baseVertex);
+          baseVertex += 24;
+          barData.push({ si, di, cx: x, cy, cz: z, height, name: s.name, value: height });
+        }
+      }
+      const vertArr = new Float32Array(verts);
+      const use32 = baseVertex > 65535;
+      const idxArr = use32 ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(vertArr);
+      else vbo = createVertexBuffer(gl, vertArr, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      indexType = use32 ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("mesh");
+      const progress = ctx.animationProgress;
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      const animModel = mat4();
+      mat4Identity(animModel);
+      animModel[5] = progress;
+      prog.setMat4("u_model", animModel);
+      mat3NormalFromMat4(normalMatrix, animModel);
+      prog.setMat3("u_normalMatrix", normalMatrix);
+      setLightUniforms(prog, defaultLightConfig(), camera.position);
+      prog.setFloat("u_opacity", 1);
+      if (!vbo || !ibo || indexCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_normal"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 }
+      ]);
+      applyVertexLayout(gl, layout);
+      ibo.bind();
+      gl.drawElements(gl.TRIANGLES, indexCount, indexType, 0);
+      disableVertexLayout(gl, layout);
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height } = ctx;
+      let closest = null;
+      let closestDist = 30;
+      for (const d of barData) {
+        const screen = projectToScreen(new Float32Array([d.cx, d.cy, d.cz]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: d.si, dataIndex: d.di, value: d.value, x: d.cx, y: d.cy, z: d.cz, seriesName: d.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      barData = [];
+    }
+  };
+}
+
+// src/charts/surface3d/surface3d-type.ts
+function heightToColor(v, min, range) {
+  const t = range > 0 ? (v - min) / range : 0.5;
+  if (t < 0.2) {
+    const s2 = t / 0.2;
+    return [0.1 + s2 * 0.05, 0.15 + s2 * 0.35, 0.6 + s2 * 0.2];
+  }
+  if (t < 0.4) {
+    const s2 = (t - 0.2) / 0.2;
+    return [0.15 - s2 * 0.05, 0.5 + s2 * 0.3, 0.8 - s2 * 0.25];
+  }
+  if (t < 0.6) {
+    const s2 = (t - 0.4) / 0.2;
+    return [0.1 + s2 * 0.6, 0.8 - s2 * 0.1, 0.55 - s2 * 0.35];
+  }
+  if (t < 0.8) {
+    const s2 = (t - 0.6) / 0.2;
+    return [0.7 + s2 * 0.28, 0.7 - s2 * 0.2, 0.2 - s2 * 0.05];
+  }
+  const s = (t - 0.8) / 0.2;
+  return [0.98, 0.5 - s * 0.15, 0.15 + s * 0.2];
+}
+function createSurface3DPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let indexType = 0;
+  let drawMode = 0;
+  const modelMatrix = mat4();
+  const normalMatrix = new Float32Array(9);
+  let gridPoints = [];
+  return {
+    type: "surface3d",
+    prepare(ctx) {
+      const { renderer, data, options } = ctx;
+      const gl = renderer.gl;
+      const grid = data.grid;
+      if (!grid || grid.length === 0) return;
+      renderer.registerProgram(
+        "mesh",
+        MESH_VERT,
+        MESH_FRAG,
+        [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
+        MESH_VERT_ATTRIBUTES
+      );
+      const rows = grid.length;
+      const cols = grid[0].length;
+      let min = Infinity, max = -Infinity;
+      for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+        const v = grid[r][c];
+        if (v < min) min = v;
+        if (v > max) max = v;
+      }
+      const range = max - min;
+      const verts = new Float32Array(rows * cols * 9);
+      gridPoints = [];
+      let vi = 0;
+      for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+        const y = grid[r][c];
+        const x = c / (cols - 1 || 1) * 10 - 5;
+        const z = r / (rows - 1 || 1) * 10 - 5;
+        const yl = c > 0 ? grid[r][c - 1] : y;
+        const yr = c < cols - 1 ? grid[r][c + 1] : y;
+        const yd = r > 0 ? grid[r - 1][c] : y;
+        const yu = r < rows - 1 ? grid[r + 1][c] : y;
+        const dx = 10 / (cols - 1 || 1), dz = 10 / (rows - 1 || 1);
+        const nx = (yl - yr) / (2 * dx), nz = (yd - yu) / (2 * dz);
+        const len = Math.sqrt(nx * nx + 1 + nz * nz);
+        const color = heightToColor(y, min, range);
+        verts[vi++] = x;
+        verts[vi++] = y;
+        verts[vi++] = z;
+        verts[vi++] = nx / len;
+        verts[vi++] = 1 / len;
+        verts[vi++] = nz / len;
+        verts[vi++] = color[0];
+        verts[vi++] = color[1];
+        verts[vi++] = color[2];
+        gridPoints.push({ x, y, z, row: r, col: c });
+      }
+      const isWireframe = options.wireframe === true;
+      const indices = [];
+      if (isWireframe) {
+        for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+          const idx = r * cols + c;
+          if (c < cols - 1) indices.push(idx, idx + 1);
+          if (r < rows - 1) indices.push(idx, idx + cols);
+        }
+        drawMode = gl.LINES;
+      } else {
+        for (let r = 0; r < rows - 1; r++) for (let c = 0; c < cols - 1; c++) {
+          const tl = r * cols + c;
+          indices.push(tl, tl + cols, tl + 1, tl + 1, tl + cols, tl + cols + 1);
+        }
+        drawMode = gl.TRIANGLES;
+      }
+      const maxIdx = rows * cols;
+      const use32 = maxIdx > 65535;
+      const idxArr = use32 ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(verts);
+      else vbo = createVertexBuffer(gl, verts, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      indexType = use32 ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("mesh");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      prog.setMat4("u_model", modelMatrix);
+      mat3NormalFromMat4(normalMatrix, modelMatrix);
+      prog.setMat3("u_normalMatrix", normalMatrix);
+      setLightUniforms(prog, defaultLightConfig(), camera.position);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (!vbo || !ibo || indexCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_normal"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 }
+      ]);
+      applyVertexLayout(gl, layout);
+      ibo.bind();
+      gl.disable(gl.CULL_FACE);
+      gl.drawElements(drawMode, indexCount, indexType, 0);
+      gl.enable(gl.CULL_FACE);
+      disableVertexLayout(gl, layout);
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height, data } = ctx;
+      let closest = null;
+      let closestDist = 20;
+      for (const gp of gridPoints) {
+        const screen = projectToScreen(new Float32Array([gp.x, gp.y, gp.z]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: 0, dataIndex: gp.row * (data.grid?.[0]?.length ?? 0) + gp.col, value: gp.y, x: gp.x, y: gp.y, z: gp.z, seriesName: `[${gp.row},${gp.col}]` };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      gridPoints = [];
+    }
+  };
+}
+
+// src/charts/globe3d/globe3d-type.ts
+function latLngToXYZ(lat, lng, radius) {
+  const phi = (90 - lat) * Math.PI / 180;
+  const theta = (lng + 180) * Math.PI / 180;
+  return [-radius * Math.sin(phi) * Math.cos(theta), radius * Math.cos(phi), radius * Math.sin(phi) * Math.sin(theta)];
+}
+function createGlobe3DPlugin() {
+  let sphereVBO = null;
+  let sphereIBO = null;
+  let sphereIndexCount = 0;
+  let pointVBO = null;
+  let pointCount = 0;
+  const modelMatrix = mat4();
+  const normalMatrix = new Float32Array(9);
+  let globePoints = [];
+  return {
+    type: "globe3d",
+    prepare(ctx) {
+      const { renderer, data, theme } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "mesh",
+        MESH_VERT,
+        MESH_FRAG,
+        [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
+        MESH_VERT_ATTRIBUTES
+      );
+      renderer.registerProgram(
+        "point3d",
+        POINT_VERT,
+        POINT_FRAG,
+        [...POINT_VERT_UNIFORMS, ...POINT_FRAG_UNIFORMS],
+        POINT_VERT_ATTRIBUTES
+      );
+      const globeRadius = 3;
+      const segments = 64, rings = 32;
+      const sphereColor = [0.12, 0.22, 0.48];
+      const sv = [], si = [];
+      for (let ring = 0; ring <= rings; ring++) {
+        const phi = ring / rings * Math.PI;
+        for (let seg = 0; seg <= segments; seg++) {
+          const theta = seg / segments * Math.PI * 2;
+          const nx = Math.sin(phi) * Math.cos(theta), ny = Math.cos(phi), nz = Math.sin(phi) * Math.sin(theta);
+          sv.push(nx * globeRadius, ny * globeRadius, nz * globeRadius, nx, ny, nz, ...sphereColor);
+        }
+      }
+      for (let ring = 0; ring < rings; ring++) for (let seg = 0; seg < segments; seg++) {
+        const a = ring * (segments + 1) + seg, b = a + segments + 1;
+        si.push(a, b, a + 1, a + 1, b, b + 1);
+      }
+      if (sphereVBO) sphereVBO.update(new Float32Array(sv));
+      else sphereVBO = createVertexBuffer(gl, new Float32Array(sv), gl.STATIC_DRAW);
+      if (sphereIBO) sphereIBO.update(new Uint16Array(si));
+      else sphereIBO = createIndexBuffer(gl, new Uint16Array(si), gl.STATIC_DRAW);
+      sphereIndexCount = si.length;
+      globePoints = [];
+      const pv = [];
+      for (let sIdx = 0; sIdx < series.length; sIdx++) {
+        const s = series[sIdx];
+        const color = hexToRGB(s.color ?? theme.colors[sIdx % theme.colors.length]);
+        for (let di = 0; di < s.values.length; di++) {
+          const lat = s.y?.[di] ?? 0, lng = s.x?.[di] ?? 0, value = s.values[di];
+          const [wx, wy, wz] = latLngToXYZ(lat, lng, globeRadius * (1 + value * 5e-3));
+          pv.push(wx, wy, wz, color[0], color[1], color[2], Math.max(4, value * 0.3));
+          globePoints.push({ si: sIdx, di, lat, lng, wx, wy, wz, value, name: s.name });
+        }
+      }
+      if (pointVBO) pointVBO.update(new Float32Array(pv));
+      else pointVBO = createVertexBuffer(gl, new Float32Array(pv), gl.DYNAMIC_DRAW);
+      pointCount = globePoints.length;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const progress = ctx.animationProgress;
+      const meshProg = renderer.getProgram("mesh");
+      meshProg.use();
+      meshProg.setMat4("u_projView", camera.projViewMatrix);
+      meshProg.setMat4("u_model", modelMatrix);
+      mat3NormalFromMat4(normalMatrix, modelMatrix);
+      meshProg.setMat3("u_normalMatrix", normalMatrix);
+      setLightUniforms(meshProg, defaultLightConfig(), camera.position);
+      meshProg.setFloat("u_opacity", progress * 0.9);
+      if (sphereVBO && sphereIBO) {
+        sphereVBO.bind();
+        const ml = createVertexLayout([
+          { location: meshProg.attributes["a_position"], size: 3 },
+          { location: meshProg.attributes["a_normal"], size: 3 },
+          { location: meshProg.attributes["a_color"], size: 3 }
+        ]);
+        applyVertexLayout(gl, ml);
+        sphereIBO.bind();
+        gl.drawElements(gl.TRIANGLES, sphereIndexCount, gl.UNSIGNED_SHORT, 0);
+        disableVertexLayout(gl, ml);
+      }
+      const pointProg = renderer.getProgram("point3d");
+      if (pointProg && pointVBO && pointCount > 0) {
+        pointProg.use();
+        pointProg.setMat4("u_projView", camera.projViewMatrix);
+        pointProg.setMat4("u_model", modelMatrix);
+        pointProg.setFloat("u_pixelRatio", renderer.pixelRatio);
+        pointProg.setFloat("u_sizeAttenuation", 30);
+        pointProg.setFloat("u_opacity", progress);
+        pointVBO.bind();
+        const pl = createVertexLayout([
+          { location: pointProg.attributes["a_position"], size: 3 },
+          { location: pointProg.attributes["a_color"], size: 3 },
+          { location: pointProg.attributes["a_size"], size: 1 }
+        ]);
+        applyVertexLayout(gl, pl);
+        gl.drawArrays(gl.POINTS, 0, pointCount);
+        disableVertexLayout(gl, pl);
+      }
+    },
+    needsLoop() {
+      return false;
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height } = ctx;
+      let closest = null;
+      let closestDist = 20;
+      for (const gp of globePoints) {
+        const screen = projectToScreen(new Float32Array([gp.wx, gp.wy, gp.wz]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: gp.si, dataIndex: gp.di, value: gp.value, x: gp.lng, y: gp.lat, seriesName: gp.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      sphereVBO?.destroy();
+      sphereVBO = null;
+      sphereIBO?.destroy();
+      sphereIBO = null;
+      pointVBO?.destroy();
+      pointVBO = null;
+      globePoints = [];
+    }
+  };
+}
+
+// src/charts/map3d/map3d-type.ts
+function valueToColor(v, min, range) {
+  const t = range > 0 ? (v - min) / range : 0.5;
+  return [0.2 + t * 0.6, 0.3 + (1 - t) * 0.4, 0.8 - t * 0.5];
+}
+function createMap3DPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let indexType = 0;
+  const modelMatrix = mat4();
+  const normalMatrix = new Float32Array(9);
+  let regionData = [];
+  return {
+    type: "map3d",
+    prepare(ctx) {
+      const { renderer, data, options } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "mesh",
+        MESH_VERT,
+        MESH_FRAG,
+        [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
+        MESH_VERT_ATTRIBUTES
+      );
+      const verts = [], indices = [];
+      regionData = [];
+      let baseVertex = 0;
+      let min = Infinity, max = -Infinity;
+      for (const s of series) for (const v of s.values) {
+        if (v < min) min = v;
+        if (v > max) max = v;
+      }
+      const range = max - min;
+      const extrudeHeight = options["extrudeHeight"] ?? 1;
+      for (let si = 0; si < series.length; si++) {
+        const s = series[si];
+        for (let di = 0; di < s.values.length; di++) {
+          const value = s.values[di], height = value / (max || 1) * extrudeHeight;
+          const color = valueToColor(value, min, range);
+          const px = s.x?.[di] ?? di % 10 * 1.2, pz = s.z?.[di] ?? Math.floor(di / 10) * 1.2;
+          const w = 0.9, d = 0.9, topY = height;
+          const darker = [color[0] * 0.7, color[1] * 0.7, color[2] * 0.7];
+          verts.push(px, topY, pz, 0, 1, 0, ...color, px + w, topY, pz, 0, 1, 0, ...color, px + w, topY, pz + d, 0, 1, 0, ...color, px, topY, pz + d, 0, 1, 0, ...color);
+          indices.push(baseVertex, baseVertex + 1, baseVertex + 2, baseVertex, baseVertex + 2, baseVertex + 3);
+          baseVertex += 4;
+          const sides = [
+            [[px, 0, pz], [px + w, 0, pz], [px + w, topY, pz], [px, topY, pz], [0, 0, -1]],
+            [[px + w, 0, pz], [px + w, 0, pz + d], [px + w, topY, pz + d], [px + w, topY, pz], [1, 0, 0]],
+            [[px + w, 0, pz + d], [px, 0, pz + d], [px, topY, pz + d], [px + w, topY, pz + d], [0, 0, 1]],
+            [[px, 0, pz + d], [px, 0, pz], [px, topY, pz], [px, topY, pz + d], [-1, 0, 0]]
+          ];
+          for (const [p0, p1, p2, p3, n] of sides) {
+            verts.push(p0[0], p0[1], p0[2], n[0], n[1], n[2], ...darker);
+            verts.push(p1[0], p1[1], p1[2], n[0], n[1], n[2], ...darker);
+            verts.push(p2[0], p2[1], p2[2], n[0], n[1], n[2], ...darker);
+            verts.push(p3[0], p3[1], p3[2], n[0], n[1], n[2], ...darker);
+            indices.push(baseVertex, baseVertex + 1, baseVertex + 2, baseVertex, baseVertex + 2, baseVertex + 3);
+            baseVertex += 4;
+          }
+          regionData.push({ name: data.categories?.[di] ?? s.name, cx: px + w * 0.5, cy: topY, cz: pz + d * 0.5, value, si, di });
+        }
+      }
+      const vertArr = new Float32Array(verts);
+      const use32 = baseVertex > 65535;
+      const idxArr = use32 ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(vertArr);
+      else vbo = createVertexBuffer(gl, vertArr, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      indexType = use32 ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("mesh");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      const animModel = mat4();
+      mat4Identity(animModel);
+      animModel[5] = ctx.animationProgress;
+      prog.setMat4("u_model", animModel);
+      mat3NormalFromMat4(normalMatrix, animModel);
+      prog.setMat3("u_normalMatrix", normalMatrix);
+      setLightUniforms(prog, defaultLightConfig(), camera.position);
+      prog.setFloat("u_opacity", 1);
+      if (!vbo || !ibo || indexCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_normal"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 }
+      ]);
+      applyVertexLayout(gl, layout);
+      ibo.bind();
+      gl.drawElements(gl.TRIANGLES, indexCount, indexType, 0);
+      disableVertexLayout(gl, layout);
+    },
+    renderOverlay(ctx, ctx2d) {
+      ctx2d.font = `${ctx.theme.fontSize}px ${ctx.theme.fontFamily}`;
+      ctx2d.fillStyle = ctx.theme.textColor;
+      ctx2d.textAlign = "center";
+      for (const r of regionData) {
+        const screen = projectToScreen(new Float32Array([r.cx, r.cy + 0.3, r.cz]), ctx.camera.projViewMatrix, ctx.width, ctx.height);
+        if (screen && screen.z > -1 && screen.z < 1) ctx2d.fillText(r.name, screen.x, screen.y);
+      }
+    },
+    hitTest(ctx, x, y) {
+      let closest = null;
+      let closestDist = 30;
+      for (const r of regionData) {
+        const screen = projectToScreen(new Float32Array([r.cx, r.cy, r.cz]), ctx.camera.projViewMatrix, ctx.width, ctx.height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: r.si, dataIndex: r.di, value: r.value, x: r.cx, y: r.cy, z: r.cz, seriesName: r.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      regionData = [];
+    }
+  };
+}
+
+// src/shaders/line.vert.ts
+var LINE_VERT = (
+  /* glsl */
+  `
+precision highp float;
+
+${PROJECTION_UNIFORMS}
+
+attribute vec3 a_position;
+attribute vec3 a_next;
+attribute vec3 a_color;
+attribute float a_side;
+
+uniform vec2 u_resolution;
+uniform float u_lineWidth;
+
+varying vec3 v_color;
+varying float v_side;
+
+void main() {
+  vec4 clipCurrent = u_projView * u_model * vec4(a_position, 1.0);
+  vec4 clipNext = u_projView * u_model * vec4(a_next, 1.0);
+
+  vec2 screenCurrent = clipCurrent.xy / clipCurrent.w * u_resolution * 0.5;
+  vec2 screenNext = clipNext.xy / clipNext.w * u_resolution * 0.5;
+
+  vec2 dir = screenNext - screenCurrent;
+  float len = length(dir);
+  dir = len > 0.001 ? dir / len : vec2(1.0, 0.0);
+  vec2 normal = vec2(-dir.y, dir.x);
+
+  vec2 offset = normal * u_lineWidth * 0.5 * a_side;
+  vec2 finalScreen = screenCurrent + offset;
+
+  gl_Position = vec4(finalScreen / (u_resolution * 0.5) * clipCurrent.w, clipCurrent.z, clipCurrent.w);
+  v_color = a_color;
+  v_side = a_side;
+}
+`
+);
+var LINE_VERT_UNIFORMS = [
+  "u_projView",
+  "u_model",
+  "u_resolution",
+  "u_lineWidth"
+];
+var LINE_VERT_ATTRIBUTES = [
+  "a_position",
+  "a_next",
+  "a_color",
+  "a_side"
+];
+
+// src/shaders/line.frag.ts
+var LINE_FRAG = (
+  /* glsl */
+  `
+precision highp float;
+
+uniform float u_opacity;
+
+varying vec3 v_color;
+varying float v_side;
+
+void main() {
+  float alpha = 1.0 - smoothstep(0.9, 1.0, abs(v_side));
+  gl_FragColor = vec4(v_color, alpha * u_opacity);
+}
+`
+);
+var LINE_FRAG_UNIFORMS = ["u_opacity"];
+
+// src/charts/lines3d/lines3d-type.ts
+function createLines3DPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let indexType = 0;
+  const modelMatrix = mat4();
+  let linePoints = [];
+  return {
+    type: "lines3d",
+    prepare(ctx) {
+      const { renderer, data, theme } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "line3d",
+        LINE_VERT,
+        LINE_FRAG,
+        [...LINE_VERT_UNIFORMS, ...LINE_FRAG_UNIFORMS],
+        LINE_VERT_ATTRIBUTES
+      );
+      const verts = [];
+      const indices = [];
+      linePoints = [];
+      let baseVertex = 0;
+      for (let si = 0; si < series.length; si++) {
+        const s = series[si];
+        const color = hexToRGB(s.color ?? theme.colors[si % theme.colors.length]);
+        for (let di = 0; di < s.values.length - 1; di++) {
+          const x0 = s.x?.[di] ?? di, y0 = s.values[di], z0 = s.z?.[di] ?? 0;
+          const x1 = s.x?.[di + 1] ?? di + 1, y1 = s.values[di + 1], z1 = s.z?.[di + 1] ?? 0;
+          for (const side of [-1, 1]) verts.push(x0, y0, z0, x1, y1, z1, color[0], color[1], color[2], side);
+          for (const side of [-1, 1]) verts.push(x1, y1, z1, x1, y1, z1, color[0], color[1], color[2], side);
+          indices.push(baseVertex, baseVertex + 2, baseVertex + 1, baseVertex + 1, baseVertex + 2, baseVertex + 3);
+          baseVertex += 4;
+          if (di === 0) linePoints.push({ si, di, x: x0, y: y0, z: z0, value: y0, name: s.name });
+          linePoints.push({ si, di: di + 1, x: x1, y: y1, z: z1, value: y1, name: s.name });
+        }
+      }
+      const vertArr = new Float32Array(verts);
+      const use32 = baseVertex > 65535;
+      const idxArr = use32 ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(vertArr);
+      else vbo = createVertexBuffer(gl, vertArr, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      indexType = use32 ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("line3d");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      prog.setMat4("u_model", modelMatrix);
+      prog.setVec2("u_resolution", ctx.width * renderer.pixelRatio, ctx.height * renderer.pixelRatio);
+      prog.setFloat("u_lineWidth", (ctx.options.lineWidth ?? 2) * renderer.pixelRatio);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (!vbo || !ibo || indexCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_next"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 },
+        { location: prog.attributes["a_side"], size: 1 }
+      ]);
+      applyVertexLayout(gl, layout);
+      gl.disable(gl.CULL_FACE);
+      ibo.bind();
+      gl.drawElements(gl.TRIANGLES, indexCount, indexType, 0);
+      gl.enable(gl.CULL_FACE);
+      disableVertexLayout(gl, layout);
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height } = ctx;
+      let closest = null;
+      let closestDist = 15;
+      for (const d of linePoints) {
+        const screen = projectToScreen(new Float32Array([d.x, d.y, d.z]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: d.si, dataIndex: d.di, value: d.value, x: d.x, y: d.y, z: d.z, seriesName: d.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      linePoints = [];
+    }
+  };
+}
+
+// src/charts/line3d/line3d-type.ts
+function createLine3DPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let indexType = 0;
+  const modelMatrix = mat4();
+  const normalMatrix = new Float32Array(9);
+  let tubePoints = [];
+  return {
+    type: "line3d",
+    prepare(ctx) {
+      const { renderer, data, options, theme } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      const s = series[0];
+      if (!s || s.values.length < 2) return;
+      renderer.registerProgram(
+        "mesh",
+        MESH_VERT,
+        MESH_FRAG,
+        [...MESH_VERT_UNIFORMS, ...MESH_FRAG_UNIFORMS],
+        MESH_VERT_ATTRIBUTES
+      );
+      const tubeRadius = options["tubeRadius"] ?? 0.15;
+      const tubeSides = options["tubeSides"] ?? 8;
+      const color = hexToRGB(s.color ?? theme.colors[0]);
+      const n = s.values.length;
+      const points = [];
+      for (let i = 0; i < n; i++) points.push([s.x?.[i] ?? i, s.values[i], s.z?.[i] ?? 0]);
+      const tangents = [];
+      for (let i = 0; i < n; i++) {
+        const prev = points[Math.max(0, i - 1)], next = points[Math.min(n - 1, i + 1)];
+        const t = vec3(next[0] - prev[0], next[1] - prev[1], next[2] - prev[2]);
+        vec3Normalize(t, t);
+        tangents.push([t[0], t[1], t[2]]);
+      }
+      const t0 = tangents[0];
+      const initNormal = Math.abs(t0[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+      const normals = [];
+      const binormals = [];
+      const N = vec3(0, 0, 0), B = vec3(0, 0, 0);
+      const T = vec3(t0[0], t0[1], t0[2]);
+      vec3Cross(B, T, vec3(initNormal[0], initNormal[1], initNormal[2]));
+      vec3Normalize(B, B);
+      vec3Cross(N, B, T);
+      vec3Normalize(N, N);
+      normals.push([N[0], N[1], N[2]]);
+      binormals.push([B[0], B[1], B[2]]);
+      for (let i = 1; i < n; i++) {
+        const t = tangents[i];
+        const T2 = vec3(t[0], t[1], t[2]);
+        vec3Cross(B, T2, N);
+        vec3Normalize(B, B);
+        vec3Cross(N, B, T2);
+        vec3Normalize(N, N);
+        normals.push([N[0], N[1], N[2]]);
+        binormals.push([B[0], B[1], B[2]]);
+      }
+      const verts = [];
+      const indices = [];
+      tubePoints = [];
+      for (let i = 0; i < n; i++) {
+        const p = points[i], nm = normals[i], bi = binormals[i];
+        for (let j = 0; j < tubeSides; j++) {
+          const angle = j / tubeSides * Math.PI * 2;
+          const cos = Math.cos(angle), sin = Math.sin(angle);
+          const nx = nm[0] * cos + bi[0] * sin, ny = nm[1] * cos + bi[1] * sin, nz = nm[2] * cos + bi[2] * sin;
+          verts.push(p[0] + nx * tubeRadius, p[1] + ny * tubeRadius, p[2] + nz * tubeRadius, nx, ny, nz, color[0], color[1], color[2]);
+        }
+        tubePoints.push({ di: i, x: p[0], y: p[1], z: p[2], value: s.values[i], name: s.name });
+      }
+      for (let i = 0; i < n - 1; i++) for (let j = 0; j < tubeSides; j++) {
+        const j2 = (j + 1) % tubeSides;
+        const a = i * tubeSides + j, b = i * tubeSides + j2, c = (i + 1) * tubeSides + j, d = (i + 1) * tubeSides + j2;
+        indices.push(a, c, b, b, c, d);
+      }
+      const vertArr = new Float32Array(verts);
+      const use32 = verts.length / 9 > 65535;
+      const idxArr = use32 ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(vertArr);
+      else vbo = createVertexBuffer(gl, vertArr, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      indexType = use32 ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      mat4Identity(modelMatrix);
+    },
+    render(ctx) {
+      const { renderer, camera } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("mesh");
+      prog.use();
+      prog.setMat4("u_projView", camera.projViewMatrix);
+      prog.setMat4("u_model", modelMatrix);
+      mat3NormalFromMat4(normalMatrix, modelMatrix);
+      prog.setMat3("u_normalMatrix", normalMatrix);
+      setLightUniforms(prog, defaultLightConfig(), camera.position);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (!vbo || !ibo || indexCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 3 },
+        { location: prog.attributes["a_normal"], size: 3 },
+        { location: prog.attributes["a_color"], size: 3 }
+      ]);
+      applyVertexLayout(gl, layout);
+      ibo.bind();
+      gl.drawElements(gl.TRIANGLES, indexCount, indexType, 0);
+      disableVertexLayout(gl, layout);
+    },
+    hitTest(ctx, x, y) {
+      const { camera, width, height } = ctx;
+      let closest = null;
+      let closestDist = 15;
+      for (const d of tubePoints) {
+        const screen = projectToScreen(new Float32Array([d.x, d.y, d.z]), camera.projViewMatrix, width, height);
+        if (!screen || screen.z < -1 || screen.z > 1) continue;
+        const dist = Math.sqrt((screen.x - x) ** 2 + (screen.y - y) ** 2);
+        if (dist < closestDist) {
+          closestDist = dist;
+          closest = { seriesIndex: 0, dataIndex: d.di, value: d.value, x: d.x, y: d.y, z: d.z, seriesName: d.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      tubePoints = [];
+    }
+  };
+}
+
+// src/shaders/flat.vert.ts
+var FLAT_VERT = (
+  /* glsl */
+  `
+precision highp float;
+
+attribute vec2 a_position;
+attribute vec3 a_color;
+attribute float a_size;
+
+uniform vec2 u_resolution;
+uniform float u_pixelRatio;
+
+varying vec3 v_color;
+
+void main() {
+  // Convert pixel coords to clip space
+  vec2 clipPos = (a_position / u_resolution) * 2.0 - 1.0;
+  clipPos.y = -clipPos.y; // flip Y for screen coords
+  gl_Position = vec4(clipPos, 0.0, 1.0);
+  gl_PointSize = a_size * u_pixelRatio;
+  v_color = a_color;
+}
+`
+);
+var FLAT_VERT_UNIFORMS = ["u_resolution", "u_pixelRatio"];
+var FLAT_VERT_ATTRIBUTES = ["a_position", "a_color", "a_size"];
+
+// src/charts/scatter-gl/scatter-gl-type.ts
+var GRID_SIZE = 64;
+function toGridKey(gx, gy) {
+  return gy * GRID_SIZE + gx;
+}
+function screenToGrid(sx, sy, w, h) {
+  return [Math.floor(sx / w * GRID_SIZE) | 0, Math.floor(sy / h * GRID_SIZE) | 0];
+}
+function niceScale(min, max, maxTicks) {
+  const range = max - min || 1;
+  const rawStep = range / maxTicks;
+  const mag = Math.pow(10, Math.floor(Math.log10(rawStep)));
+  const norm = rawStep / mag;
+  const step = norm < 1.5 ? mag : norm < 3 ? 2 * mag : norm < 7 ? 5 * mag : 10 * mag;
+  const start = Math.ceil(min / step) * step;
+  const ticks = [];
+  for (let v = start; v <= max + step * 1e-3; v += step) ticks.push(v);
+  return ticks;
+}
+function formatTick(v) {
+  if (Math.abs(v) >= 1e6) return (v / 1e6).toFixed(1) + "M";
+  if (Math.abs(v) >= 1e3) return (v / 1e3).toFixed(1) + "K";
+  if (Number.isInteger(v)) return String(v);
+  return v.toFixed(Math.abs(v) < 1 ? 2 : 1);
+}
+var MARGIN = { top: 20, right: 20, bottom: 40, left: 55 };
+function createScatterGLPlugin() {
+  let vbo = null;
+  let pointCount = 0;
+  let gridCells = /* @__PURE__ */ new Map();
+  let dataBounds = { minX: 0, maxX: 1, minY: 0, maxY: 1 };
+  let seriesInfo = [];
+  return {
+    type: "scatter-gl",
+    prepare(ctx) {
+      const { renderer, data, options, theme, width, height } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "flat-point",
+        FLAT_VERT,
+        POINT_FRAG,
+        [...FLAT_VERT_UNIFORMS, ...POINT_FRAG_UNIFORMS],
+        FLAT_VERT_ATTRIBUTES
+      );
+      let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+      for (const s of series) for (let i = 0; i < s.x.length; i++) {
+        const x = s.x[i], y = s.y[i];
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+      if (minX === Infinity) {
+        minX = 0;
+        maxX = 100;
+        minY = 0;
+        maxY = 100;
+      }
+      const padX = (maxX - minX) * 0.05 || 0.5;
+      const padY = (maxY - minY) * 0.05 || 0.5;
+      minX -= padX;
+      maxX += padX;
+      minY -= padY;
+      maxY += padY;
+      dataBounds = { minX, maxX, minY, maxY };
+      const rangeX = maxX - minX || 1, rangeY = maxY - minY || 1;
+      const plotLeft = MARGIN.left, plotRight = width - MARGIN.right;
+      const plotTop = MARGIN.top, plotBottom = height - MARGIN.bottom;
+      const plotW = plotRight - plotLeft, plotH = plotBottom - plotTop;
+      let totalPoints = 0;
+      for (const s of series) totalPoints += s.x.length;
+      const verts = new Float32Array(totalPoints * 6);
+      gridCells = /* @__PURE__ */ new Map();
+      seriesInfo = [];
+      let vi = 0;
+      const defaultSize = options.pointSize ?? 4;
+      for (let si = 0; si < series.length; si++) {
+        const s = series[si];
+        const colorHex = s.color ?? theme.colors[si % theme.colors.length];
+        const color = hexToRGB(colorHex);
+        const size = s.size ?? defaultSize;
+        seriesInfo.push({ name: s.name, color: colorHex, count: s.x.length });
+        for (let di = 0; di < s.x.length; di++) {
+          const sx = plotLeft + (s.x[di] - minX) / rangeX * plotW;
+          const sy = plotTop + (1 - (s.y[di] - minY) / rangeY) * plotH;
+          verts[vi++] = sx;
+          verts[vi++] = sy;
+          verts[vi++] = color[0];
+          verts[vi++] = color[1];
+          verts[vi++] = color[2];
+          verts[vi++] = size;
+          const [gx, gy] = screenToGrid(sx, sy, width, height);
+          if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {
+            const key = toGridKey(gx, gy);
+            let cell = gridCells.get(key);
+            if (!cell) {
+              cell = [];
+              gridCells.set(key, cell);
+            }
+            cell.push({ si, di, sx, sy, value: s.y[di], name: s.name });
+          }
+        }
+      }
+      if (vbo) vbo.update(verts);
+      else vbo = createVertexBuffer(gl, verts, gl.DYNAMIC_DRAW);
+      pointCount = totalPoints;
+    },
+    render(ctx) {
+      const { renderer } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("flat-point");
+      prog.use();
+      prog.setVec2("u_resolution", ctx.width, ctx.height);
+      prog.setFloat("u_pixelRatio", renderer.pixelRatio);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (!vbo || pointCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 2 },
+        { location: prog.attributes["a_color"], size: 3 },
+        { location: prog.attributes["a_size"], size: 1 }
+      ]);
+      applyVertexLayout(gl, layout);
+      gl.disable(gl.DEPTH_TEST);
+      gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
+      gl.drawArrays(gl.POINTS, 0, pointCount);
+      gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+      gl.enable(gl.DEPTH_TEST);
+      disableVertexLayout(gl, layout);
+    },
+    renderOverlay(ctx, ctx2d) {
+      const { width, height, theme } = ctx;
+      const { minX, maxX, minY, maxY } = dataBounds;
+      const plotLeft = MARGIN.left, plotRight = width - MARGIN.right;
+      const plotTop = MARGIN.top, plotBottom = height - MARGIN.bottom;
+      const plotW = plotRight - plotLeft, plotH = plotBottom - plotTop;
+      const rangeX = maxX - minX || 1, rangeY = maxY - minY || 1;
+      ctx2d.save();
+      const xTicks = niceScale(minX, maxX, 6);
+      const yTicks = niceScale(minY, maxY, 5);
+      ctx2d.strokeStyle = theme.gridColor;
+      ctx2d.lineWidth = 1;
+      ctx2d.globalAlpha = 0.4;
+      ctx2d.beginPath();
+      for (const v of xTicks) {
+        const sx = plotLeft + (v - minX) / rangeX * plotW;
+        ctx2d.moveTo(sx, plotTop);
+        ctx2d.lineTo(sx, plotBottom);
+      }
+      for (const v of yTicks) {
+        const sy = plotTop + (1 - (v - minY) / rangeY) * plotH;
+        ctx2d.moveTo(plotLeft, sy);
+        ctx2d.lineTo(plotRight, sy);
+      }
+      ctx2d.stroke();
+      ctx2d.globalAlpha = 1;
+      ctx2d.strokeStyle = theme.textColor;
+      ctx2d.globalAlpha = 0.5;
+      ctx2d.lineWidth = 1;
+      ctx2d.beginPath();
+      ctx2d.moveTo(plotLeft, plotTop);
+      ctx2d.lineTo(plotLeft, plotBottom);
+      ctx2d.lineTo(plotRight, plotBottom);
+      ctx2d.stroke();
+      ctx2d.globalAlpha = 1;
+      ctx2d.font = `${theme.fontSize - 1}px ${theme.fontFamily}`;
+      ctx2d.fillStyle = theme.textColor;
+      ctx2d.globalAlpha = 0.7;
+      ctx2d.textAlign = "center";
+      ctx2d.textBaseline = "top";
+      for (const v of xTicks) {
+        const sx = plotLeft + (v - minX) / rangeX * plotW;
+        ctx2d.fillText(formatTick(v), sx, plotBottom + 6);
+      }
+      ctx2d.textAlign = "right";
+      ctx2d.textBaseline = "middle";
+      for (const v of yTicks) {
+        const sy = plotTop + (1 - (v - minY) / rangeY) * plotH;
+        ctx2d.fillText(formatTick(v), plotLeft - 8, sy);
+      }
+      ctx2d.globalAlpha = 1;
+      if (seriesInfo.length > 1) {
+        const legendX = plotRight - 10;
+        let legendY = plotTop + 8;
+        ctx2d.textAlign = "right";
+        ctx2d.textBaseline = "top";
+        ctx2d.font = `${theme.fontSize - 1}px ${theme.fontFamily}`;
+        for (const s of seriesInfo) {
+          ctx2d.fillStyle = s.color;
+          ctx2d.globalAlpha = 0.9;
+          ctx2d.beginPath();
+          ctx2d.arc(legendX - ctx2d.measureText(s.name).width - 10, legendY + 6, 4, 0, Math.PI * 2);
+          ctx2d.fill();
+          ctx2d.fillStyle = theme.textColor;
+          ctx2d.globalAlpha = 0.8;
+          ctx2d.fillText(s.name, legendX, legendY);
+          legendY += 18;
+        }
+      }
+      ctx2d.textAlign = "left";
+      ctx2d.textBaseline = "top";
+      ctx2d.font = `${theme.fontSize - 2}px ${theme.fontFamily}`;
+      ctx2d.fillStyle = theme.textColor;
+      ctx2d.globalAlpha = 0.4;
+      const totalPts = seriesInfo.reduce((sum, s) => sum + s.count, 0);
+      const label = totalPts >= 1e3 ? `${(totalPts / 1e3).toFixed(totalPts >= 1e4 ? 0 : 1)}K points` : `${totalPts} points`;
+      ctx2d.fillText(label, plotLeft + 4, plotTop + 4);
+      ctx2d.restore();
+    },
+    hitTest(ctx, x, y) {
+      const { width, height } = ctx;
+      const [gx, gy] = screenToGrid(x, y, width, height);
+      let closest = null;
+      let closestDist = 10;
+      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+        const cx = gx + dx, cy = gy + dy;
+        if (cx < 0 || cx >= GRID_SIZE || cy < 0 || cy >= GRID_SIZE) continue;
+        const cell = gridCells.get(toGridKey(cx, cy));
+        if (!cell) continue;
+        for (const p of cell) {
+          const d = Math.sqrt((p.sx - x) ** 2 + (p.sy - y) ** 2);
+          if (d < closestDist) {
+            closestDist = d;
+            closest = { seriesIndex: p.si, dataIndex: p.di, value: p.value, x: p.sx, y: p.sy, seriesName: p.name };
+          }
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      gridCells.clear();
+    }
+  };
+}
+
+// src/charts/lines-gl/lines-gl-type.ts
+var FLAT_LINE_VERT = `precision highp float; attribute vec2 a_position; attribute vec2 a_next; attribute vec3 a_color; attribute float a_side; uniform vec2 u_resolution; uniform float u_lineWidth; varying vec3 v_color; void main() { vec2 dir = a_next - a_position; float len = length(dir); dir = len > 0.001 ? dir / len : vec2(1.0, 0.0); vec2 normal = vec2(-dir.y, dir.x); vec2 pos = a_position + normal * u_lineWidth * 0.5 * a_side; vec2 c = (pos / u_resolution) * 2.0 - 1.0; c.y = -c.y; gl_Position = vec4(c, 0.0, 1.0); v_color = a_color; }`;
+var FLAT_LINE_FRAG = `precision highp float; uniform float u_opacity; varying vec3 v_color; void main() { gl_FragColor = vec4(v_color, u_opacity); }`;
+function createLinesGLPlugin() {
+  let vbo = null;
+  let ibo = null;
+  let indexCount = 0;
+  let indexType = 0;
+  let linePoints = [];
+  return {
+    type: "lines-gl",
+    prepare(ctx) {
+      const { renderer, data, theme, width, height } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "flat-line",
+        FLAT_LINE_VERT,
+        FLAT_LINE_FRAG,
+        ["u_resolution", "u_lineWidth", "u_opacity"],
+        ["a_position", "a_next", "a_color", "a_side"]
+      );
+      let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+      for (const s of series) for (let i = 0; i < s.x.length; i++) {
+        const x = s.x[i], y = s.y[i];
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+      const rangeX = maxX - minX || 1, rangeY = maxY - minY || 1, margin = 40;
+      const toScreen = (dx, dy) => [
+        margin + (dx - minX) / rangeX * (width - margin * 2),
+        margin + (1 - (dy - minY) / rangeY) * (height - margin * 2)
+      ];
+      const verts = [], indices = [];
+      linePoints = [];
+      let baseVertex = 0;
+      for (let si = 0; si < series.length; si++) {
+        const s = series[si];
+        const color = hexToRGB(s.color ?? theme.colors[si % theme.colors.length]);
+        for (let di = 0; di < s.x.length; di++) {
+          const [sx, sy] = toScreen(s.x[di], s.y[di]);
+          linePoints.push({ si, di, sx, sy, value: s.y[di], name: s.name });
+        }
+        for (let di = 0; di < s.x.length - 1; di++) {
+          const [sx0, sy0] = toScreen(s.x[di], s.y[di]);
+          const [sx1, sy1] = toScreen(s.x[di + 1], s.y[di + 1]);
+          for (const side of [-1, 1]) verts.push(sx0, sy0, sx1, sy1, color[0], color[1], color[2], side);
+          for (const side of [-1, 1]) verts.push(sx1, sy1, sx1, sy1, color[0], color[1], color[2], side);
+          indices.push(baseVertex, baseVertex + 2, baseVertex + 1, baseVertex + 1, baseVertex + 2, baseVertex + 3);
+          baseVertex += 4;
+        }
+      }
+      const vertArr = new Float32Array(verts);
+      const use32 = baseVertex > 65535;
+      const idxArr = use32 ? new Uint32Array(indices) : new Uint16Array(indices);
+      if (vbo) vbo.update(vertArr);
+      else vbo = createVertexBuffer(gl, vertArr, gl.DYNAMIC_DRAW);
+      if (ibo) ibo.update(idxArr);
+      else ibo = createIndexBuffer(gl, idxArr, gl.DYNAMIC_DRAW);
+      indexCount = indices.length;
+      indexType = use32 ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+    },
+    render(ctx) {
+      const { renderer } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("flat-line");
+      prog.use();
+      prog.setVec2("u_resolution", ctx.width, ctx.height);
+      prog.setFloat("u_lineWidth", ctx.options.lineWidth ?? 2);
+      prog.setFloat("u_opacity", ctx.animationProgress);
+      if (!vbo || !ibo || indexCount === 0) return;
+      vbo.bind();
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 2 },
+        { location: prog.attributes["a_next"], size: 2 },
+        { location: prog.attributes["a_color"], size: 3 },
+        { location: prog.attributes["a_side"], size: 1 }
+      ]);
+      applyVertexLayout(gl, layout);
+      gl.disable(gl.DEPTH_TEST);
+      ibo.bind();
+      gl.drawElements(gl.TRIANGLES, indexCount, indexType, 0);
+      gl.enable(gl.DEPTH_TEST);
+      disableVertexLayout(gl, layout);
+    },
+    hitTest(_ctx, x, y) {
+      let closest = null;
+      let closestDist = 10;
+      for (const p of linePoints) {
+        const d = Math.sqrt((p.sx - x) ** 2 + (p.sy - y) ** 2);
+        if (d < closestDist) {
+          closestDist = d;
+          closest = { seriesIndex: p.si, dataIndex: p.di, value: p.value, x: p.sx, y: p.sy, seriesName: p.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      ibo?.destroy();
+      ibo = null;
+      linePoints = [];
+    }
+  };
+}
+
+// src/shaders/particle.vert.ts
+var PARTICLE_VERT = (
+  /* glsl */
+  `
+precision highp float;
+
+attribute vec2 a_position;
+attribute vec2 a_velocity;
+attribute float a_age;
+attribute float a_speed;
+
+uniform vec2 u_resolution;
+uniform float u_pointSize;
+uniform float u_pixelRatio;
+uniform float u_speedRange;    // max speed for normalization
+uniform float u_sizeBySpeed;   // 0..1 how much speed affects size
+
+varying float v_age;
+varying float v_speed;         // normalized 0..1
+varying vec2 v_velocity;
+
+void main() {
+  vec2 clipPos = (a_position / u_resolution) * 2.0 - 1.0;
+  clipPos.y = -clipPos.y;
+  gl_Position = vec4(clipPos, 0.0, 1.0);
+
+  float normSpeed = clamp(a_speed / max(u_speedRange, 0.001), 0.0, 1.0);
+  v_speed = normSpeed;
+  v_age = a_age;
+  v_velocity = a_velocity;
+
+  // Size: base + speed contribution. Faster = bigger.
+  float speedScale = mix(1.0, 1.0 + normSpeed * 2.0, u_sizeBySpeed);
+  // Young particles slightly larger
+  float ageScale = 1.0 - a_age * 0.3;
+  gl_PointSize = u_pointSize * u_pixelRatio * speedScale * ageScale;
+}
+`
+);
+var PARTICLE_VERT_UNIFORMS = [
+  "u_resolution",
+  "u_pointSize",
+  "u_pixelRatio",
+  "u_speedRange",
+  "u_sizeBySpeed"
+];
+var PARTICLE_VERT_ATTRIBUTES = [
+  "a_position",
+  "a_velocity",
+  "a_age",
+  "a_speed"
+];
+
+// src/shaders/particle.frag.ts
+var PARTICLE_FRAG = (
+  /* glsl */
+  `
+precision highp float;
+
+uniform vec3 u_colorSlow;    // color at speed=0
+uniform vec3 u_colorMid;     // color at speed=0.5
+uniform vec3 u_colorFast;    // color at speed=1
+uniform float u_useSpeedColor; // 0=use vertex color, 1=use speed gradient
+
+varying float v_age;
+varying float v_speed;
+varying vec2 v_velocity;
+
+vec3 speedGradient(float t) {
+  if (t < 0.5) {
+    return mix(u_colorSlow, u_colorMid, t * 2.0);
+  }
+  return mix(u_colorMid, u_colorFast, (t - 0.5) * 2.0);
+}
+
+void main() {
+  vec2 coord = gl_PointCoord - vec2(0.5);
+
+  // Direction-aware elongation: stretch along velocity
+  float speed = length(v_velocity);
+  if (speed > 0.01) {
+    vec2 dir = normalize(v_velocity);
+    // Rotate coord into velocity-aligned frame
+    float stretch = 1.0 + v_speed * 1.5;
+    float cx = coord.x * dir.x + coord.y * dir.y;   // along velocity
+    float cy = -coord.x * dir.y + coord.y * dir.x;  // perpendicular
+    cx /= stretch;
+    coord = vec2(cx, cy);
+  }
+
+  float dist = length(coord);
+  if (dist > 0.5) discard;
+
+  // Core + glow
+  float core = 1.0 - smoothstep(0.15, 0.35, dist);
+  float glow = (1.0 - smoothstep(0.1, 0.5, dist)) * 0.6;
+  float alpha = max(core, glow);
+
+  // Age fade: quadratic for longer visible tail
+  float ageFade = 1.0 - v_age * v_age;
+  alpha *= ageFade;
+
+  // Color: speed gradient or fallback
+  vec3 color = speedGradient(v_speed);
+
+  // Brighten core of young fast particles
+  float hotspot = core * (1.0 - v_age) * v_speed;
+  color += vec3(0.3, 0.2, 0.1) * hotspot;
+
+  gl_FragColor = vec4(color, alpha);
+}
+`
+);
+var PARTICLE_FRAG_UNIFORMS = [
+  "u_colorSlow",
+  "u_colorMid",
+  "u_colorFast",
+  "u_useSpeedColor"
+];
+
+// src/charts/flow-gl/flow-gl-type.ts
+var MAX_PARTICLES = 2e4;
+var PARTICLE_FLOATS = 6;
+function createFieldFn(type, w, h) {
+  switch (type) {
+    case "wind":
+      return (x, y) => {
+        const nx = x / w, ny = y / h;
+        const base = 2.5 + Math.sin(ny * Math.PI * 2) * 0.8;
+        const gust = Math.sin(nx * 6 + ny * 3) * 0.5;
+        const vy = Math.cos(nx * 4) * 0.6 + Math.sin(ny * 5 + nx * 2) * 0.3;
+        return [base + gust, vy];
+      };
+    case "vortex":
+      return (x, y) => {
+        const cx = w / 2, cy = h / 2;
+        const dx = x - cx, dy = y - cy;
+        const dist = Math.sqrt(dx * dx + dy * dy) + 1;
+        const maxR = Math.min(w, h) * 0.45;
+        const falloff = Math.max(0, 1 - dist / maxR);
+        const strength = falloff * falloff * 4;
+        return [
+          -dy / dist * strength - dx / dist * 0.3 * falloff,
+          dx / dist * strength - dy / dist * 0.3 * falloff
+        ];
+      };
+    case "source":
+      return (x, y) => {
+        const pts = [
+          [w * 0.25, h * 0.35, 1.5],
+          [w * 0.75, h * 0.65, 1.5],
+          [w * 0.5, h * 0.5, -2.5]
+        ];
+        let vx = 0, vy = 0;
+        for (const [px, py, strength] of pts) {
+          const dx = x - px, dy = y - py;
+          const dist = Math.sqrt(dx * dx + dy * dy) + 10;
+          vx += dx / dist * strength * (50 / dist);
+          vy += dy / dist * strength * (50 / dist);
+        }
+        return [vx, vy];
+      };
+    case "turbulence":
+      return (x, y) => {
+        const nx = x / w * 6, ny = y / h * 6;
+        const vx = Math.sin(ny * 2.3 + nx) * 2 + Math.cos(nx * 1.7 - ny * 0.8) * 1.5 + Math.sin(nx * 3.1 + ny * 2.7) * 0.5;
+        const vy = Math.cos(nx * 2.1 - ny * 1.3) * 2 + Math.sin(ny * 1.9 + nx * 0.6) * 1.5 - Math.cos(ny * 2.8 + nx * 1.5) * 0.5;
+        return [vx, vy];
+      };
+    case "swirl":
+    default:
+      return (x, y) => {
+        const nx = x / w - 0.5, ny = y / h - 0.5;
+        const angle = Math.atan2(ny, nx);
+        const dist = Math.sqrt(nx * nx + ny * ny);
+        const spiral = dist * 8 + angle * 2;
+        const strength = Math.max(0, 1 - dist * 2.5) * 3;
+        return [
+          Math.cos(spiral) * strength + Math.sin(ny * 6) * 0.5,
+          Math.sin(spiral) * strength + Math.cos(nx * 6) * 0.5
+        ];
+      };
+  }
+}
+function createFlowGLPlugin() {
+  let vbo = null;
+  let positions;
+  let velocities;
+  let ages;
+  let speeds;
+  let particleSpeeds;
+  let fieldFn = () => [1, 0];
+  let particleCount = 0;
+  let fieldWidth = 0;
+  let fieldHeight = 0;
+  let maxSpeed = 1;
+  let arrowCache = [];
+  let opts = {};
+  function resetParticle(i, w, h) {
+    positions[i * 2] = Math.random() * w;
+    positions[i * 2 + 1] = Math.random() * h;
+    ages[i] = Math.random() * 0.2;
+    particleSpeeds[i] = 0.5 + Math.random() * 1.5;
+    velocities[i * 2] = 0;
+    velocities[i * 2 + 1] = 0;
+    speeds[i] = 0;
+  }
+  function sampleArrows(w, h, density) {
+    arrowCache = [];
+    const stepX = w / density, stepY = h / density;
+    let trackMaxSpeed = 0;
+    for (let gy = 0; gy < density; gy++) {
+      for (let gx = 0; gx < density; gx++) {
+        const x = stepX * (gx + 0.5), y = stepY * (gy + 0.5);
+        const [vx, vy] = fieldFn(x, y);
+        const speed = Math.sqrt(vx * vx + vy * vy);
+        if (speed > trackMaxSpeed) trackMaxSpeed = speed;
+        arrowCache.push({ x, y, vx, vy, speed });
+      }
+    }
+    maxSpeed = Math.max(trackMaxSpeed, 0.01);
+  }
+  return {
+    type: "flow-gl",
+    prepare(ctx) {
+      const { renderer, data, options, width, height } = ctx;
+      const gl = renderer.gl;
+      renderer.registerProgram(
+        "particle",
+        PARTICLE_VERT,
+        PARTICLE_FRAG,
+        [...PARTICLE_VERT_UNIFORMS, ...PARTICLE_FRAG_UNIFORMS],
+        PARTICLE_VERT_ATTRIBUTES
+      );
+      fieldWidth = width;
+      fieldHeight = height;
+      opts = options;
+      if (data.grid && data.grid.length > 0) {
+        const rows = data.grid.length, cols = data.grid[0].length / 2;
+        fieldFn = (x, y) => {
+          const cx = Math.max(0, Math.min(cols - 1, Math.floor(x / width * (cols - 1))));
+          const cy = Math.max(0, Math.min(rows - 1, Math.floor(y / height * (rows - 1))));
+          return [data.grid[cy][cx * 2] ?? 0, data.grid[cy][cx * 2 + 1] ?? 0];
+        };
+      } else {
+        const fieldType = opts.fieldType ?? "swirl";
+        fieldFn = createFieldFn(fieldType, width, height);
+      }
+      particleCount = Math.min(MAX_PARTICLES, opts.particleCount ?? 5e3);
+      positions = new Float32Array(particleCount * 2);
+      velocities = new Float32Array(particleCount * 2);
+      ages = new Float32Array(particleCount);
+      speeds = new Float32Array(particleCount);
+      particleSpeeds = new Float32Array(particleCount);
+      for (let i = 0; i < particleCount; i++) resetParticle(i, width, height);
+      sampleArrows(width, height, opts.arrowDensity ?? 12);
+      const vertData = new Float32Array(particleCount * PARTICLE_FLOATS);
+      if (vbo) vbo.update(vertData);
+      else vbo = createVertexBuffer(gl, vertData, gl.DYNAMIC_DRAW);
+    },
+    render(ctx) {
+      const { renderer } = ctx;
+      const gl = renderer.gl;
+      const prog = renderer.getProgram("particle");
+      const ageSpeed = opts.ageSpeed ?? 6e-3;
+      const colorSlow = hexToRGB(opts.colorSlow ?? "#1e3a5f");
+      const colorMid = hexToRGB(opts.colorMid ?? "#22d3ee");
+      const colorFast = hexToRGB(opts.colorFast ?? "#fbbf24");
+      const vertData = new Float32Array(particleCount * PARTICLE_FLOATS);
+      let frameMaxSpeed = 0;
+      for (let i = 0; i < particleCount; i++) {
+        const px = positions[i * 2], py = positions[i * 2 + 1];
+        const [u, v] = fieldFn(px, py);
+        const spd = Math.sqrt(u * u + v * v);
+        if (spd > frameMaxSpeed) frameMaxSpeed = spd;
+        velocities[i * 2] = velocities[i * 2] * 0.7 + u * 0.3;
+        velocities[i * 2 + 1] = velocities[i * 2 + 1] * 0.7 + v * 0.3;
+        speeds[i] = spd;
+        const vx = velocities[i * 2], vy = velocities[i * 2 + 1];
+        positions[i * 2] = px + vx * particleSpeeds[i];
+        positions[i * 2 + 1] = py + vy * particleSpeeds[i];
+        ages[i] = ages[i] + ageSpeed;
+        if (ages[i] > 1 || positions[i * 2] < 0 || positions[i * 2] > fieldWidth || positions[i * 2 + 1] < 0 || positions[i * 2 + 1] > fieldHeight) {
+          resetParticle(i, fieldWidth, fieldHeight);
+        }
+        const off = i * PARTICLE_FLOATS;
+        vertData[off] = positions[i * 2];
+        vertData[off + 1] = positions[i * 2 + 1];
+        vertData[off + 2] = vx;
+        vertData[off + 3] = vy;
+        vertData[off + 4] = ages[i];
+        vertData[off + 5] = speeds[i];
+      }
+      maxSpeed = maxSpeed * 0.95 + frameMaxSpeed * 0.05;
+      if (!vbo) return;
+      vbo.update(vertData);
+      vbo.bind();
+      prog.use();
+      prog.setVec2("u_resolution", ctx.width, ctx.height);
+      prog.setFloat("u_pointSize", opts.pointSize ?? 4);
+      prog.setFloat("u_pixelRatio", renderer.pixelRatio);
+      prog.setFloat("u_speedRange", maxSpeed);
+      prog.setFloat("u_sizeBySpeed", opts.sizeBySpeed ?? 0.7);
+      prog.setVec3("u_colorSlow", colorSlow[0], colorSlow[1], colorSlow[2]);
+      prog.setVec3("u_colorMid", colorMid[0], colorMid[1], colorMid[2]);
+      prog.setVec3("u_colorFast", colorFast[0], colorFast[1], colorFast[2]);
+      prog.setFloat("u_useSpeedColor", 1);
+      const layout = createVertexLayout([
+        { location: prog.attributes["a_position"], size: 2 },
+        { location: prog.attributes["a_velocity"], size: 2 },
+        { location: prog.attributes["a_age"], size: 1 },
+        { location: prog.attributes["a_speed"], size: 1 }
+      ]);
+      applyVertexLayout(gl, layout);
+      gl.disable(gl.DEPTH_TEST);
+      gl.drawArrays(gl.POINTS, 0, particleCount);
+      gl.enable(gl.DEPTH_TEST);
+      disableVertexLayout(gl, layout);
+    },
+    renderOverlay(ctx, ctx2d) {
+      const showArrows = opts.showArrows ?? true;
+      const showLegend = opts.showLegend ?? true;
+      const { width, height, theme } = ctx;
+      if (showArrows && arrowCache.length > 0) {
+        ctx2d.save();
+        const arrowLen = Math.min(width, height) / (opts.arrowDensity ?? 12) * 0.35;
+        for (const a of arrowCache) {
+          const speed = a.speed;
+          if (speed < 0.01) continue;
+          const nx = a.vx / speed, ny = a.vy / speed;
+          const norm = Math.min(speed / maxSpeed, 1);
+          ctx2d.globalAlpha = 0.12 + norm * 0.18;
+          ctx2d.strokeStyle = theme.textColor;
+          ctx2d.lineWidth = 1;
+          ctx2d.beginPath();
+          const len = arrowLen * (0.3 + norm * 0.7);
+          const ex = a.x + nx * len, ey = a.y + ny * len;
+          ctx2d.moveTo(a.x - nx * len * 0.3, a.y - ny * len * 0.3);
+          ctx2d.lineTo(ex, ey);
+          const headLen = len * 0.3;
+          const hx1 = ex - headLen * (nx * 0.8 + ny * 0.5);
+          const hy1 = ey - headLen * (ny * 0.8 - nx * 0.5);
+          const hx2 = ex - headLen * (nx * 0.8 - ny * 0.5);
+          const hy2 = ey - headLen * (ny * 0.8 + nx * 0.5);
+          ctx2d.moveTo(ex, ey);
+          ctx2d.lineTo(hx1, hy1);
+          ctx2d.moveTo(ex, ey);
+          ctx2d.lineTo(hx2, hy2);
+          ctx2d.stroke();
+        }
+        ctx2d.restore();
+      }
+      if (showLegend) {
+        ctx2d.save();
+        const lx = width - 140, ly = height - 50;
+        const lw = 120, lh = 10;
+        const colorSlow = opts.colorSlow ?? "#1e3a5f";
+        const colorMid = opts.colorMid ?? "#22d3ee";
+        const colorFast = opts.colorFast ?? "#fbbf24";
+        const grad = ctx2d.createLinearGradient(lx, 0, lx + lw, 0);
+        grad.addColorStop(0, colorSlow);
+        grad.addColorStop(0.5, colorMid);
+        grad.addColorStop(1, colorFast);
+        ctx2d.fillStyle = "rgba(0,0,0,0.4)";
+        ctx2d.beginPath();
+        ctx2d.roundRect(lx - 10, ly - 20, lw + 20, lh + 36, 6);
+        ctx2d.fill();
+        ctx2d.fillStyle = grad;
+        ctx2d.beginPath();
+        ctx2d.roundRect(lx, ly, lw, lh, 3);
+        ctx2d.fill();
+        ctx2d.font = `${theme.fontSize - 2}px ${theme.fontFamily}`;
+        ctx2d.fillStyle = "rgba(255,255,255,0.7)";
+        ctx2d.textAlign = "left";
+        ctx2d.fillText("Slow", lx, ly + lh + 14);
+        ctx2d.textAlign = "center";
+        ctx2d.fillText("Speed", lx + lw / 2, ly - 6);
+        ctx2d.textAlign = "right";
+        ctx2d.fillText("Fast", lx + lw, ly + lh + 14);
+        ctx2d.restore();
+      }
+    },
+    needsLoop() {
+      return true;
+    },
+    hitTest() {
+      return null;
+    },
+    dispose() {
+      vbo?.destroy();
+      vbo = null;
+      arrowCache = [];
+    }
+  };
+}
+
+// src/charts/graph-gl/graph-gl-type.ts
+function insertNode(quad, node) {
+  if (quad.mass === 0 && !quad.body) {
+    quad.body = node;
+    quad.cx = node.x;
+    quad.cy = node.y;
+    quad.mass = 1;
+    return;
+  }
+  if (quad.body) {
+    const existing = quad.body;
+    quad.body = null;
+    insertIntoChild(quad, existing);
+  }
+  quad.cx = (quad.cx * quad.mass + node.x) / (quad.mass + 1);
+  quad.cy = (quad.cy * quad.mass + node.y) / (quad.mass + 1);
+  quad.mass += 1;
+  insertIntoChild(quad, node);
+}
+function insertIntoChild(quad, node) {
+  const midX = (quad.x0 + quad.x1) / 2, midY = (quad.y0 + quad.y1) / 2;
+  const idx = (node.x > midX ? 1 : 0) + (node.y > midY ? 2 : 0);
+  if (!quad.children[idx]) {
+    quad.children[idx] = { cx: 0, cy: 0, mass: 0, x0: idx & 1 ? midX : quad.x0, y0: idx & 2 ? midY : quad.y0, x1: idx & 1 ? quad.x1 : midX, y1: idx & 2 ? quad.y1 : midY, children: [null, null, null, null], body: null };
+  }
+  insertNode(quad.children[idx], node);
+}
+function applyBarnesHut(quad, node, theta, repulsion) {
+  if (quad.mass === 0) return;
+  const dx = quad.cx - node.x, dy = quad.cy - node.y;
+  const dist = Math.sqrt(dx * dx + dy * dy) + 0.01;
+  if ((quad.x1 - quad.x0) / dist < theta || quad.mass === 1) {
+    const force = -500 * quad.mass / (dist * dist);
+    node.vx += force * dx / dist;
+    node.vy += force * dy / dist;
+    return;
+  }
+  for (const child of quad.children) if (child) applyBarnesHut(child, node, theta);
+}
+var EDGE_VERT = `precision highp float; attribute vec2 a_position; attribute vec3 a_color; uniform vec2 u_resolution; varying vec3 v_color; void main() { vec2 c = (a_position / u_resolution) * 2.0 - 1.0; c.y = -c.y; gl_Position = vec4(c, 0.0, 1.0); v_color = a_color; }`;
+var EDGE_FRAG = `precision highp float; uniform float u_opacity; varying vec3 v_color; void main() { gl_FragColor = vec4(v_color, u_opacity * 0.4); }`;
+function createGraphGLPlugin() {
+  let nodeVBO = null;
+  let edgeVBO = null;
+  let nodeCount = 0;
+  let nodes = [];
+  let edges = [];
+  let simulating = true;
+  let simIterations = 0;
+  const MAX_ITER = 300;
+  function stepSim(w, h) {
+    if (!simulating || simIterations >= MAX_ITER) {
+      simulating = false;
+      return;
+    }
+    const root = { cx: 0, cy: 0, mass: 0, x0: 0, y0: 0, x1: w, y1: h, children: [null, null, null, null], body: null };
+    for (const n of nodes) insertNode(root, n);
+    for (const n of nodes) applyBarnesHut(root, n, 0.8);
+    for (const e of edges) {
+      const s = nodes[e.source], t = nodes[e.target];
+      const dx = t.x - s.x, dy = t.y - s.y, dist = Math.sqrt(dx * dx + dy * dy) + 0.01;
+      const f = 0.01 * (dist - 100), fx = f * dx / dist, fy = f * dy / dist;
+      s.vx += fx;
+      s.vy += fy;
+      t.vx -= fx;
+      t.vy -= fy;
+    }
+    const cx = w / 2, cy = h / 2;
+    for (const n of nodes) {
+      n.vx += (cx - n.x) * 1e-3;
+      n.vy += (cy - n.y) * 1e-3;
+      n.vx *= 0.9;
+      n.vy *= 0.9;
+      n.x = Math.max(20, Math.min(w - 20, n.x + n.vx));
+      n.y = Math.max(20, Math.min(h - 20, n.y + n.vy));
+    }
+    simIterations++;
+  }
+  return {
+    type: "graph-gl",
+    prepare(ctx) {
+      const { renderer, data, options, width, height } = ctx;
+      const gl = renderer.gl;
+      const series = data.series;
+      renderer.registerProgram(
+        "flat-point",
+        FLAT_VERT,
+        POINT_FRAG,
+        [...FLAT_VERT_UNIFORMS, ...POINT_FRAG_UNIFORMS],
+        FLAT_VERT_ATTRIBUTES
+      );
+      renderer.registerProgram(
+        "edge",
+        EDGE_VERT,
+        EDGE_FRAG,
+        ["u_resolution", "u_opacity"],
+        ["a_position", "a_color"]
+      );
+      nodes = [];
+      edges = options["edges"] ?? [];
+      const s = series[0];
+      if (s) {
+        for (let i = 0; i < s.x.length; i++) {
+          nodes.push({ x: Math.random() * (width - 40) + 20, y: Math.random() * (height - 40) + 20, vx: 0, vy: 0, name: data.categories?.[i] ?? `N${i}`, value: s.y[i] ?? 1, si: 0, di: i });
+        }
+        if (edges.length === 0) for (let i = 0; i < nodes.length; i++) {
+          for (let e = 0; e < Math.min(3, Math.floor(Math.random() * 4)); e++) {
+            const t = Math.floor(Math.random() * nodes.length);
+            if (t !== i) edges.push({ source: i, target: t });
+          }
+        }
+      }
+      simulating = true;
+      simIterations = 0;
+      if (nodeVBO) nodeVBO.update(new Float32Array(nodes.length * 6));
+      else nodeVBO = createVertexBuffer(gl, new Float32Array(nodes.length * 6), gl.DYNAMIC_DRAW);
+      if (edgeVBO) edgeVBO.update(new Float32Array(edges.length * 10));
+      else edgeVBO = createVertexBuffer(gl, new Float32Array(edges.length * 10), gl.DYNAMIC_DRAW);
+      nodeCount = nodes.length;
+    },
+    render(ctx) {
+      const { renderer, theme } = ctx;
+      const gl = renderer.gl;
+      const progress = ctx.animationProgress;
+      if (simulating) for (let i = 0; i < 5; i++) stepSim(ctx.width, ctx.height);
+      const edgeColor = hexToRGB(theme.gridColor);
+      const defaultSize = ctx.options.pointSize ?? 6;
+      const ed = new Float32Array(edges.length * 10);
+      for (let i = 0; i < edges.length; i++) {
+        const s = nodes[edges[i].source], t = nodes[edges[i].target];
+        const o = i * 10;
+        ed[o] = s.x;
+        ed[o + 1] = s.y;
+        ed[o + 2] = edgeColor[0];
+        ed[o + 3] = edgeColor[1];
+        ed[o + 4] = edgeColor[2];
+        ed[o + 5] = t.x;
+        ed[o + 6] = t.y;
+        ed[o + 7] = edgeColor[0];
+        ed[o + 8] = edgeColor[1];
+        ed[o + 9] = edgeColor[2];
+      }
+      if (edgeVBO) edgeVBO.update(ed);
+      const ep = renderer.getProgram("edge");
+      ep.use();
+      ep.setVec2("u_resolution", ctx.width, ctx.height);
+      ep.setFloat("u_opacity", progress);
+      if (edgeVBO) {
+        edgeVBO.bind();
+        const el = createVertexLayout([{ location: ep.attributes["a_position"], size: 2 }, { location: ep.attributes["a_color"], size: 3 }]);
+        applyVertexLayout(gl, el);
+        gl.disable(gl.DEPTH_TEST);
+        gl.drawArrays(gl.LINES, 0, edges.length * 2);
+        disableVertexLayout(gl, el);
+      }
+      const nd = new Float32Array(nodes.length * 6);
+      for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i], color = hexToRGB(theme.colors[i % theme.colors.length]);
+        const o = i * 6;
+        nd[o] = n.x;
+        nd[o + 1] = n.y;
+        nd[o + 2] = color[0];
+        nd[o + 3] = color[1];
+        nd[o + 4] = color[2];
+        nd[o + 5] = defaultSize + n.value * 0.5;
+      }
+      if (nodeVBO) nodeVBO.update(nd);
+      const pp = renderer.getProgram("flat-point");
+      pp.use();
+      pp.setVec2("u_resolution", ctx.width, ctx.height);
+      pp.setFloat("u_pixelRatio", renderer.pixelRatio);
+      pp.setFloat("u_opacity", progress);
+      if (nodeVBO) {
+        nodeVBO.bind();
+        const nl = createVertexLayout([{ location: pp.attributes["a_position"], size: 2 }, { location: pp.attributes["a_color"], size: 3 }, { location: pp.attributes["a_size"], size: 1 }]);
+        applyVertexLayout(gl, nl);
+        gl.drawArrays(gl.POINTS, 0, nodeCount);
+        gl.enable(gl.DEPTH_TEST);
+        disableVertexLayout(gl, nl);
+      }
+    },
+    needsLoop() {
+      return simulating;
+    },
+    renderOverlay(ctx, ctx2d) {
+      ctx2d.font = `${ctx.theme.fontSize - 1}px ${ctx.theme.fontFamily}`;
+      ctx2d.fillStyle = ctx.theme.textColor;
+      ctx2d.textAlign = "center";
+      for (const n of nodes) ctx2d.fillText(n.name, n.x, n.y - 8);
+    },
+    hitTest(_ctx, x, y) {
+      let closest = null;
+      let closestDist = 15;
+      for (const n of nodes) {
+        const d = Math.sqrt((n.x - x) ** 2 + (n.y - y) ** 2);
+        if (d < closestDist) {
+          closestDist = d;
+          closest = { seriesIndex: n.si, dataIndex: n.di, value: n.value, x: n.x, y: n.y, seriesName: n.name };
+        }
+      }
+      return closest;
+    },
+    dispose() {
+      nodeVBO?.destroy();
+      nodeVBO = null;
+      edgeVBO?.destroy();
+      edgeVBO = null;
+      nodes = [];
+      edges = [];
+    }
+  };
+}
+
+// src/api/factory.ts
+function Scatter3D(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createScatter3DPlugin(), data, options);
+}
+function Bar3D(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createBar3DPlugin(), data, options);
+}
+function Surface3D(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createSurface3DPlugin(), data, options);
+}
+function Globe3D(container, opts) {
+  const { data, ...options } = opts;
+  if (!options.orbit) options.orbit = { autoRotate: true, autoRotateSpeed: 0.5 };
+  if (!options.camera) options.camera = { position: [0, 2, 9], target: [0, 0, 0] };
+  return createGLChart(container, createGlobe3DPlugin(), data, options);
+}
+function Map3D(container, opts) {
+  const { data, ...options } = opts;
+  if (!options.camera) {
+    const series = data.series;
+    let minX = Infinity, maxX = -Infinity, minZ = Infinity, maxZ = -Infinity;
+    for (const s of series) {
+      if (s.x) for (const v of s.x) {
+        if (v < minX) minX = v;
+        if (v > maxX) maxX = v;
+      }
+      if (s.z) for (const v of s.z) {
+        if (v < minZ) minZ = v;
+        if (v > maxZ) maxZ = v;
+      }
+    }
+    if (minX === Infinity) {
+      minX = 0;
+      maxX = 10;
+    }
+    if (minZ === Infinity) {
+      minZ = 0;
+      maxZ = 10;
+    }
+    const cx = (minX + maxX) / 2, cz = (minZ + maxZ) / 2;
+    const ext = Math.max(maxX - minX, maxZ - minZ, 1);
+    const dist = Math.max(ext * 1.8, 5);
+    options.camera = {
+      position: [cx + dist * 0.6, dist * 0.5, cz + dist * 0.6],
+      target: [cx, 0, cz]
+    };
+  }
+  return createGLChart(container, createMap3DPlugin(), data, options);
+}
+function Lines3D(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createLines3DPlugin(), data, options);
+}
+function Line3D(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createLine3DPlugin(), data, options);
+}
+function ScatterGL(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createScatterGLPlugin(), data, options);
+}
+function LinesGL(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createLinesGLPlugin(), data, options);
+}
+function FlowGL(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createFlowGLPlugin(), data, options);
+}
+function GraphGL(container, opts) {
+  const { data, ...options } = opts;
+  return createGLChart(container, createGraphGLPlugin(), data, options);
+}
+
+exports.Bar3D = Bar3D;
+exports.DEFAULT_GL_THEME = DEFAULT_GL_THEME;
+exports.FlowGL = FlowGL;
+exports.Globe3D = Globe3D;
+exports.GraphGL = GraphGL;
+exports.LIGHT_GL_THEME = LIGHT_GL_THEME;
+exports.Line3D = Line3D;
+exports.Lines3D = Lines3D;
+exports.LinesGL = LinesGL;
+exports.Map3D = Map3D;
+exports.Scatter3D = Scatter3D;
+exports.ScatterGL = ScatterGL;
+exports.Surface3D = Surface3D;
+exports.applyVertexLayout = applyVertexLayout;
+exports.compileShader = compileShader;
+exports.createBar3DPlugin = createBar3DPlugin;
+exports.createCamera = createCamera;
+exports.createFlowGLPlugin = createFlowGLPlugin;
+exports.createGLChart = createGLChart;
+exports.createGLRenderer = createGLRenderer;
+exports.createGlobe3DPlugin = createGlobe3DPlugin;
+exports.createGraphGLPlugin = createGraphGLPlugin;
+exports.createGrid3D = createGrid3D;
+exports.createIndexBuffer = createIndexBuffer;
+exports.createLine3DPlugin = createLine3DPlugin;
+exports.createLines3DPlugin = createLines3DPlugin;
+exports.createLinesGLPlugin = createLinesGLPlugin;
+exports.createMap3DPlugin = createMap3DPlugin;
+exports.createOrbitControls = createOrbitControls;
+exports.createPickingSystem = createPickingSystem;
+exports.createScatter3DPlugin = createScatter3DPlugin;
+exports.createScatterGLPlugin = createScatterGLPlugin;
+exports.createShaderProgram = createShaderProgram;
+exports.createSurface3DPlugin = createSurface3DPlugin;
+exports.createVertexBuffer = createVertexBuffer;
+exports.createVertexLayout = createVertexLayout;
+exports.defaultLightConfig = defaultLightConfig;
+exports.hexToRGB = hexToRGB;
+exports.mat4 = mat4;
+exports.mat4Identity = mat4Identity;
+exports.mat4Invert = mat4Invert;
+exports.mat4LookAt = mat4LookAt;
+exports.mat4Multiply = mat4Multiply;
+exports.mat4Perspective = mat4Perspective;
+exports.projectToScreen = projectToScreen;
+exports.resolveTheme = resolveTheme;
+exports.setLightUniforms = setLightUniforms;
+exports.toRad = toRad;
+exports.updateCamera = updateCamera;
+exports.updateOrbitControls = updateOrbitControls;
+exports.vec3 = vec3;
+//# sourceMappingURL=chunk-Q4JAQOV3.cjs.map
+//# sourceMappingURL=chunk-Q4JAQOV3.cjs.map