@rosalana/sandbox 0.0.1

package/dist/index.es.js

@@ -0,0 +1,1107 @@
+var S = Object.defineProperty;
+var L = (o, t, e) => t in o ? S(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var i = (o, t, e) => L(o, typeof t != "symbol" ? t + "" : t, e);
+class l {
+  constructor(t, e, r, s) {
+    this.target = t, this.type = e, this.listener = r, this.options = s, this.target.addEventListener(
+      this.type,
+      this.listener,
+      this.options
+    );
+  }
+  remove() {
+    this.target.removeEventListener(
+      this.type,
+      this.listener,
+      this.options
+    );
+  }
+  static on(t, e, r, s) {
+    return t.addEventListener(e, r, s), () => t.removeEventListener(e, r, s);
+  }
+}
+class u extends Error {
+  constructor(t, e) {
+    super(t), this.code = e, this.name = "SandboxError";
+  }
+}
+class w extends u {
+  constructor(t) {
+    const e = t === "not_supported" ? "WebGL is not supported in this browser." : "Failed to create WebGL context. The GPU may be unavailable.";
+    super(
+      e,
+      t === "not_supported" ? "WEBGL_NOT_SUPPORTED" : "CONTEXT_CREATION_FAILED"
+    ), this.name = "SandboxContextError";
+  }
+}
+class k extends u {
+  constructor(t, e) {
+    super(
+      `Vertex and fragment shader WebGL versions do not match (${t} vs ${e})`,
+      "SHADER_VERSION_MISMATCH"
+    ), this.vertexVersion = t, this.fragmentVersion = e, this.name = "SandboxShaderVersionMismatchError";
+  }
+}
+class f extends u {
+  constructor(e, r, s) {
+    const n = f.parseErrorLines(s), a = n.length > 0 ? ` at line(s): ${n.join(", ")}` : "";
+    super(
+      `${e} shader compilation failed${a}
+
+${s}`,
+      "SHADER_COMPILATION_FAILED"
+    );
+    /** Line numbers where errors occurred */
+    i(this, "lines");
+    this.shaderType = e, this.source = r, this.infoLog = s, this.name = "SandboxShaderCompilationError", this.lines = n;
+  }
+  /** Parse error log to extract line numbers */
+  static parseErrorLines(e) {
+    const r = [
+      /ERROR:\s*\d*:(\d+)/g,
+      // Chrome/ANGLE: ERROR: 0:15
+      /(\d+):(\d+)\(\d+\):/g,
+      // Mesa: 0:15(0):
+      /^(\d+):/gm
+      // Simple: 15:
+    ], s = /* @__PURE__ */ new Set();
+    for (const n of r) {
+      let a;
+      for (; (a = n.exec(e)) !== null; ) {
+        const c = parseInt(a[1], 10);
+        c > 0 && s.add(c);
+      }
+    }
+    return [...s].sort((n, a) => n - a);
+  }
+}
+class m extends u {
+  constructor(t) {
+    super(`Shader program linking failed
+
+${t}`, "PROGRAM_LINK_FAILED"), this.infoLog = t, this.name = "SandboxProgramError";
+  }
+}
+class R {
+  constructor() {
+    /** Total elapsed time in seconds */
+    i(this, "time", 0);
+    /** Delta time since last frame in seconds */
+    i(this, "delta", 0);
+    /** Frame counter */
+    i(this, "frame", 0);
+    /** Is clock running */
+    i(this, "running", !1);
+    i(this, "startTime", 0);
+    i(this, "lastTime", 0);
+    i(this, "rafId", null);
+    i(this, "callback", null);
+    this.loop = this.loop.bind(this);
+  }
+  /**
+   * Start the animation loop with a render callback.
+   */
+  start(t) {
+    if (this.running) return this;
+    this.callback = t, this.running = !0;
+    const e = performance.now();
+    return this.startTime = e, this.lastTime = e, this.rafId = requestAnimationFrame(this.loop), this;
+  }
+  /**
+   * Stop the animation loop.
+   * Clock state is preserved for resume.
+   */
+  stop() {
+    return this.running ? (this.running = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this) : this;
+  }
+  /**
+   * Reset clock to initial state.
+   */
+  reset() {
+    return this.stop(), this.time = 0, this.delta = 0, this.frame = 0, this;
+  }
+  /**
+   * Get current clock state snapshot.
+   */
+  getState() {
+    return {
+      time: this.time,
+      delta: this.delta,
+      frame: this.frame
+    };
+  }
+  /**
+   * Advance clock by one tick (for single-shot rendering).
+   * Useful when autoplay is disabled.
+   */
+  tick(t = 0) {
+    return this.delta = t, this.time += t, this.frame++, this.callback && this.callback(this.getState()), this;
+  }
+  /**
+   * Set time directly (for deterministic rendering).
+   */
+  setTime(t) {
+    return this.time = t, this;
+  }
+  /**
+   * Cleanup.
+   */
+  destroy() {
+    this.stop(), this.callback = null;
+  }
+  /**
+   * Internal animation frame handler.
+   */
+  loop(t) {
+    this.running && (this.delta = (t - this.lastTime) / 1e3, this.lastTime = t, this.time = (t - this.startTime) / 1e3, this.frame++, this.callback && this.callback(this.getState()), this.rafId = requestAnimationFrame(this.loop));
+  }
+}
+class p {
+  constructor(t) {
+    i(this, "gl");
+    i(this, "vao", null);
+    i(this, "vbo", null);
+    i(this, "ibo", null);
+    i(this, "vertexCount", 0);
+    i(this, "indexCount", 0);
+    i(this, "useIndices", !1);
+    // WebGL1 VAO extension (if available)
+    i(this, "vaoExt", null);
+    i(this, "isWebGL2");
+    this.gl = t, this.isWebGL2 = t instanceof WebGL2RenderingContext, this.isWebGL2 || (this.vaoExt = t.getExtension("OES_vertex_array_object"));
+  }
+  /**
+   * Create a fullscreen quad geometry.
+   * This is the most common use case for shader effects.
+   */
+  static fullscreenQuad(t) {
+    const e = new p(t), r = new Float32Array([
+      // position    texcoord
+      -1,
+      -1,
+      0,
+      0,
+      // bottom-left
+      1,
+      -1,
+      1,
+      0,
+      // bottom-right
+      -1,
+      1,
+      0,
+      1,
+      // top-left
+      1,
+      1,
+      1,
+      1
+      // top-right
+    ]), s = new Uint16Array([
+      0,
+      1,
+      2,
+      // first triangle
+      2,
+      1,
+      3
+      // second triangle
+    ]);
+    return e.setup(r, s), e;
+  }
+  /**
+   * Setup geometry from vertex and index data.
+   */
+  setup(t, e) {
+    const r = this.gl;
+    return this.createVAO(), this.bindVAO(), this.vbo = r.createBuffer(), r.bindBuffer(r.ARRAY_BUFFER, this.vbo), r.bufferData(r.ARRAY_BUFFER, t, r.STATIC_DRAW), this.vertexCount = t.length / 4, e && (this.ibo = r.createBuffer(), r.bindBuffer(r.ELEMENT_ARRAY_BUFFER, this.ibo), r.bufferData(r.ELEMENT_ARRAY_BUFFER, e, r.STATIC_DRAW), this.indexCount = e.length, this.useIndices = !0), this.unbindVAO(), this;
+  }
+  /**
+   * Link vertex attributes to shader program.
+   * Call this after compiling shaders.
+   */
+  linkAttributes(t) {
+    const e = this.gl;
+    this.bindVAO(), e.bindBuffer(e.ARRAY_BUFFER, this.vbo);
+    const r = 4 * Float32Array.BYTES_PER_ELEMENT, s = this.getPositionLocation(t);
+    s >= 0 && (e.enableVertexAttribArray(s), e.vertexAttribPointer(s, 2, e.FLOAT, !1, r, 0));
+    const n = this.getTexcoordLocation(t);
+    return n >= 0 && (e.enableVertexAttribArray(n), e.vertexAttribPointer(
+      n,
+      2,
+      e.FLOAT,
+      !1,
+      r,
+      2 * Float32Array.BYTES_PER_ELEMENT
+    )), this.useIndices && e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.ibo), this.unbindVAO(), this;
+  }
+  /**
+   * Bind geometry for rendering.
+   */
+  bind() {
+    return this.bindVAO(), this;
+  }
+  /**
+   * Unbind geometry.
+   */
+  unbind() {
+    return this.unbindVAO(), this;
+  }
+  /**
+   * Draw the geometry.
+   */
+  draw() {
+    const t = this.gl;
+    return this.bindVAO(), this.useIndices ? t.drawElements(t.TRIANGLES, this.indexCount, t.UNSIGNED_SHORT, 0) : t.drawArrays(t.TRIANGLE_STRIP, 0, this.vertexCount), this;
+  }
+  /**
+   * Cleanup all GPU resources.
+   */
+  destroy() {
+    const t = this.gl;
+    this.deleteVAO(), this.vbo && (t.deleteBuffer(this.vbo), this.vbo = null), this.ibo && (t.deleteBuffer(this.ibo), this.ibo = null);
+  }
+  /**
+   * Get position attribute location.
+   * Tries common naming conventions.
+   */
+  getPositionLocation(t) {
+    let e = t.getAttribLocation("a_position");
+    return e >= 0 || (e = t.getAttribLocation("aPosition"), e >= 0) || (e = t.getAttribLocation("position"), e >= 0) ? e : -1;
+  }
+  /**
+   * Get texcoord attribute location.
+   * Tries common naming conventions.
+   */
+  getTexcoordLocation(t) {
+    let e = t.getAttribLocation("a_texcoord");
+    return e >= 0 || (e = t.getAttribLocation("aTexCoord"), e >= 0) || (e = t.getAttribLocation("texcoord"), e >= 0) || (e = t.getAttribLocation("a_uv"), e >= 0) ? e : -1;
+  }
+  // ============================================================================
+  // VAO helpers (handle WebGL1 vs WebGL2 differences)
+  // ============================================================================
+  createVAO() {
+    this.isWebGL2 ? this.vao = this.gl.createVertexArray() : this.vaoExt && (this.vao = this.vaoExt.createVertexArrayOES());
+  }
+  bindVAO() {
+    this.vao && (this.isWebGL2 ? this.gl.bindVertexArray(this.vao) : this.vaoExt && this.vaoExt.bindVertexArrayOES(this.vao));
+  }
+  unbindVAO() {
+    this.isWebGL2 ? this.gl.bindVertexArray(null) : this.vaoExt && this.vaoExt.bindVertexArrayOES(null);
+  }
+  deleteVAO() {
+    this.vao && (this.isWebGL2 ? this.gl.deleteVertexArray(this.vao) : this.vaoExt && this.vaoExt.deleteVertexArrayOES(this.vao), this.vao = null);
+  }
+}
+class h {
+  constructor(t) {
+    i(this, "gl");
+    i(this, "program", null);
+    i(this, "vertexShader", null);
+    i(this, "fragmentShader", null);
+    i(this, "version", 1);
+    this.gl = t;
+  }
+  /**
+   * Detect WebGL version from shader source.
+   * Looks for "#version 300 es" directive.
+   */
+  static detectVersion(t) {
+    return /^\s*#version\s+300\s+es/m.test(t) ? 2 : 1;
+  }
+  /**
+   * Compile shaders and link program.
+   * @throws ShaderCompilationError if compilation fails
+   * @throws ProgramLinkError if linking fails
+   */
+  compile(t, e) {
+    this.destroy();
+    const r = h.detectVersion(t), s = h.detectVersion(e);
+    if (r != s)
+      throw new k(r, s);
+    return this.version = Math.max(r, s), this.vertexShader = this.compileShader("vertex", t), this.fragmentShader = this.compileShader("fragment", e), this.linkProgram(), this;
+  }
+  /**
+   * Bind this program for rendering.
+   */
+  use() {
+    return this.program && this.gl.useProgram(this.program), this;
+  }
+  /**
+   * Get the compiled WebGL program.
+   */
+  getProgram() {
+    return this.program;
+  }
+  /**
+   * Get detected WebGL version.
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Get attribute location.
+   */
+  getAttribLocation(t) {
+    return this.program ? this.gl.getAttribLocation(this.program, t) : -1;
+  }
+  /**
+   * Get uniform location.
+   */
+  getUniformLocation(t) {
+    return this.program ? this.gl.getUniformLocation(this.program, t) : null;
+  }
+  /**
+   * Cleanup all GPU resources.
+   */
+  destroy() {
+    const t = this.gl;
+    this.program && (this.vertexShader && t.detachShader(this.program, this.vertexShader), this.fragmentShader && t.detachShader(this.program, this.fragmentShader), t.deleteProgram(this.program), this.program = null), this.vertexShader && (t.deleteShader(this.vertexShader), this.vertexShader = null), this.fragmentShader && (t.deleteShader(this.fragmentShader), this.fragmentShader = null);
+  }
+  /**
+   * Compile a single shader.
+   * @throws ShaderCompilationError if compilation fails
+   */
+  compileShader(t, e) {
+    const r = this.gl, s = t === "vertex" ? r.VERTEX_SHADER : r.FRAGMENT_SHADER, n = r.createShader(s);
+    if (!n)
+      throw new f(
+        t,
+        e,
+        "Failed to create shader object"
+      );
+    if (r.shaderSource(n, e), r.compileShader(n), !r.getShaderParameter(n, r.COMPILE_STATUS)) {
+      const c = r.getShaderInfoLog(n) || "Unknown error";
+      throw r.deleteShader(n), new f(t, e, c);
+    }
+    return n;
+  }
+  /**
+   * Link vertex and fragment shaders into a program.
+   * @throws ProgramLinkError if linking fails
+   */
+  linkProgram() {
+    const t = this.gl;
+    if (!this.vertexShader || !this.fragmentShader)
+      throw new m("Shaders not compiled");
+    const e = t.createProgram();
+    if (!e)
+      throw new m("Failed to create program object");
+    if (t.attachShader(e, this.vertexShader), t.attachShader(e, this.fragmentShader), t.linkProgram(e), !t.getProgramParameter(e, t.LINK_STATUS)) {
+      const s = t.getProgramInfoLog(e) || "Unknown error";
+      throw t.deleteProgram(e), new m(s);
+    }
+    this.program = e;
+  }
+}
+class x {
+  constructor(t, e) {
+    i(this, "name");
+    i(this, "method");
+    i(this, "isArray");
+    i(this, "isMatrix");
+    i(this, "location", null);
+    i(this, "locationResolved", !1);
+    i(this, "value");
+    this.name = t, this.value = e;
+    const r = x.inferMethodInfo(e);
+    this.method = r.method, this.isArray = r.isArray, this.isMatrix = r.isMatrix;
+  }
+  /**
+   * Infer WebGL method and metadata from value type.
+   */
+  static inferMethodInfo(t) {
+    if (typeof t == "boolean")
+      return { method: "uniform1i", isArray: !1, isMatrix: !1 };
+    if (typeof t == "number")
+      return { method: "uniform1f", isArray: !1, isMatrix: !1 };
+    if (!Array.isArray(t))
+      return { method: "uniform1f", isArray: !1, isMatrix: !1 };
+    const e = t.length, r = t[0];
+    if (Array.isArray(r))
+      switch (r.length) {
+        case 2:
+          return { method: "uniform2fv", isArray: !0, isMatrix: !1 };
+        case 3:
+          return { method: "uniform3fv", isArray: !0, isMatrix: !1 };
+        case 4:
+          return { method: "uniform4fv", isArray: !0, isMatrix: !1 };
+        default:
+          return { method: "uniform1fv", isArray: !0, isMatrix: !1 };
+      }
+    switch (e) {
+      case 2:
+        return { method: "uniform2fv", isArray: !1, isMatrix: !1 };
+      case 3:
+        return { method: "uniform3fv", isArray: !1, isMatrix: !1 };
+      case 4:
+        return { method: "uniform4fv", isArray: !1, isMatrix: !1 };
+      case 9:
+        return { method: "uniformMatrix3fv", isArray: !1, isMatrix: !0 };
+      case 16:
+        return { method: "uniformMatrix4fv", isArray: !1, isMatrix: !0 };
+      default:
+        return { method: "uniform1fv", isArray: !0, isMatrix: !1 };
+    }
+  }
+  /**
+   * Resolve and cache uniform location from program.
+   * Returns null if uniform doesn't exist (optimized out by compiler, etc.)
+   */
+  resolveLocation(t, e) {
+    return this.locationResolved || (this.location = t.getUniformLocation(e, this.name), this.locationResolved = !0), this.location;
+  }
+  /**
+   * Invalidate cached location (call when program changes).
+   */
+  invalidateLocation() {
+    this.location = null, this.locationResolved = !1;
+  }
+  /**
+   * Update value (doesn't upload to GPU until upload() is called).
+   */
+  setValue(t) {
+    this.value = t;
+  }
+  /**
+   * Get current value.
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Upload current value to GPU.
+   * @param gl - WebGL context
+   * @param program - Current WebGL program (for location resolution)
+   */
+  upload(t, e) {
+    const r = this.resolveLocation(t, e);
+    if (r === null)
+      return;
+    const s = this.value;
+    let n;
+    switch (typeof s == "boolean" ? n = s ? 1 : 0 : typeof s == "number" ? n = s : this.isArray && Array.isArray(s[0]) ? n = new Float32Array(
+      s.flat()
+    ) : n = new Float32Array(s), this.method) {
+      case "uniform1f":
+        t.uniform1f(r, n);
+        break;
+      case "uniform1i":
+        t.uniform1i(r, n);
+        break;
+      case "uniform1fv":
+        t.uniform1fv(r, n);
+        break;
+      case "uniform2fv":
+        t.uniform2fv(r, n);
+        break;
+      case "uniform3fv":
+        t.uniform3fv(r, n);
+        break;
+      case "uniform4fv":
+        t.uniform4fv(r, n);
+        break;
+      case "uniformMatrix2fv":
+        t.uniformMatrix2fv(r, !1, n);
+        break;
+      case "uniformMatrix3fv":
+        t.uniformMatrix3fv(r, !1, n);
+        break;
+      case "uniformMatrix4fv":
+        t.uniformMatrix4fv(r, !1, n);
+        break;
+    }
+  }
+}
+const d = class d {
+  constructor(t) {
+    i(this, "gl");
+    i(this, "program", null);
+    i(this, "uniforms", /* @__PURE__ */ new Map());
+    this.gl = t;
+  }
+  /**
+   * Attach to a WebGL program.
+   * Invalidates all cached locations since they're program-specific.
+   */
+  attachProgram(t) {
+    this.program = t;
+    for (const e of this.uniforms.values())
+      e.invalidateLocation();
+    return this;
+  }
+  /**
+   * Set a uniform value.
+   * Creates the uniform if it doesn't exist, updates if it does.
+   */
+  set(t, e) {
+    const r = this.uniforms.get(t);
+    return r ? r.setValue(e) : this.uniforms.set(t, new x(t, e)), this;
+  }
+  /**
+   * Set multiple uniforms at once.
+   */
+  setMany(t) {
+    for (const [e, r] of Object.entries(t))
+      this.set(e, r);
+    return this;
+  }
+  /**
+   * Get current uniform value.
+   */
+  get(t) {
+    var e;
+    return (e = this.uniforms.get(t)) == null ? void 0 : e.getValue();
+  }
+  /**
+   * Check if uniform exists.
+   */
+  has(t) {
+    return this.uniforms.has(t);
+  }
+  /**
+   * Remove a uniform.
+   */
+  delete(t) {
+    return this.uniforms.delete(t);
+  }
+  /**
+   * Upload all uniforms to GPU.
+   * Requires a program to be attached.
+   */
+  uploadAll() {
+    if (!this.program)
+      return this;
+    for (const t of this.uniforms.values())
+      t.upload(this.gl, this.program);
+    return this;
+  }
+  /**
+   * Upload only built-in uniforms (u_resolution, u_time, u_delta, u_mouse, u_frame).
+   * Call this every frame with current values.
+   */
+  uploadBuiltIns(t, e, r) {
+    if (this.set("u_resolution", e), this.set("u_time", t.time), this.set("u_delta", t.delta), this.set("u_mouse", r), this.set("u_frame", t.frame), !this.program)
+      return this;
+    for (const s of d.BUILT_INS) {
+      const n = this.uniforms.get(s);
+      n && n.upload(this.gl, this.program);
+    }
+    return this;
+  }
+  /**
+   * Clear all uniforms.
+   */
+  clear() {
+    this.uniforms.clear();
+  }
+  /**
+   * Cleanup.
+   */
+  destroy() {
+    this.uniforms.clear(), this.program = null;
+  }
+  /**
+   * Get all uniform names.
+   */
+  keys() {
+    return this.uniforms.keys();
+  }
+  /**
+   * Get uniform count.
+   */
+  get size() {
+    return this.uniforms.size;
+  }
+};
+/** Built-in uniform names that are handled automatically */
+i(d, "BUILT_INS", /* @__PURE__ */ new Set([
+  "u_resolution",
+  "u_time",
+  "u_delta",
+  "u_mouse",
+  "u_frame"
+]));
+let v = d;
+class b {
+  constructor() {
+    i(this, "hooks", /* @__PURE__ */ new Map());
+  }
+  id() {
+    return Math.random().toString(36).substring(2, 10);
+  }
+  /** Add a new hook, returns a removal function */
+  add(t) {
+    const e = this.id();
+    return this.hooks.set(e, t), () => this.remove(e);
+  }
+  /** Remove a hook by its ID */
+  remove(t) {
+    this.hooks.delete(t);
+  }
+  /** Run all hooks with the given state */
+  run(t) {
+    for (const [e, r] of this.hooks)
+      r(t) === !1 && this.remove(e);
+  }
+  destroy() {
+    this.hooks.clear();
+  }
+}
+class _ {
+  constructor(t, e) {
+    i(this, "canvas");
+    i(this, "gl");
+    i(this, "options");
+    i(this, "onBeforeHooks", new b());
+    i(this, "onAfterHooks", new b());
+    i(this, "_program");
+    i(this, "_geometry");
+    i(this, "_uniforms");
+    i(this, "_clock");
+    i(this, "_resolution", [1, 1]);
+    i(this, "_mouse", [0, 0]);
+    i(this, "_version", 1);
+    i(this, "playing", !1);
+    this.canvas = t, this.options = e, this.gl = this.initContext(), this.enableExtensions(), this._program = new h(this.gl), this._geometry = p.fullscreenQuad(this.gl), this._uniforms = new v(this.gl), this._clock = new R(), this.options.onBeforeRender && this.onBeforeHooks.add(this.options.onBeforeRender), this.options.onAfterRender && this.onAfterHooks.add(this.options.onAfterRender), this.onRender = this.onRender.bind(this);
+  }
+  /**
+   * Factory method to create and setup WebGL instance.
+   */
+  static setup(t, e) {
+    const r = new _(t, e);
+    return e.vertex && e.fragment && r.shader(e.vertex, e.fragment), e.uniforms && r._uniforms.setMany(e.uniforms), r;
+  }
+  /**
+   * Initialize WebGL context.
+   * Tries WebGL2 first, falls back to WebGL1.
+   * Context errors are fatal but still reported via onError.
+   */
+  initContext() {
+    const t = {
+      antialias: this.options.antialias,
+      preserveDrawingBuffer: this.options.preserveDrawingBuffer,
+      alpha: !0,
+      depth: !1,
+      stencil: !1
+    }, e = this.canvas.getContext("webgl2", t);
+    if (e)
+      return this._version = 2, e;
+    const r = this.canvas.getContext("webgl", t);
+    if (r)
+      return this._version = 1, r;
+    const s = new w("not_supported");
+    throw this.options.onError(s), s;
+  }
+  /**
+   * Enable useful WebGL extensions.
+   */
+  enableExtensions() {
+    this.gl.getExtension("OES_standard_derivatives"), this.gl.getExtension("OES_texture_float"), this.gl.getExtension("OES_texture_float_linear"), this._version === 1 && this.gl.getExtension("OES_vertex_array_object");
+  }
+  /**
+   * Set viewport dimensions.
+   */
+  viewport(t, e, r, s) {
+    return this.canvas.width = r, this.canvas.height = s, this.gl.viewport(t, e, r, s), this._resolution = [r, s], this;
+  }
+  /**
+   * Set the clock time
+   */
+  clock(t) {
+    return this._clock.setTime(t), this;
+  }
+  /**
+   * Update mouse position.
+   */
+  mouse(t, e) {
+    return this._mouse = [t, e], this;
+  }
+  /**
+   * Set a uniform value.
+   */
+  uniform(t, e) {
+    return this._uniforms.set(t, e), this;
+  }
+  /**
+   * Set multiple uniforms.
+   */
+  uniforms(t) {
+    return this._uniforms.setMany(t), this;
+  }
+  /**
+   * Get current uniform value.
+   */
+  getUniform(t) {
+    return this._uniforms.get(t);
+  }
+  /**
+   * Compile and link shaders.
+   * Errors are handled via onError callback, never thrown.
+   */
+  shader(t, e) {
+    try {
+      this._program.compile(t, e), this._version = this._program.getVersion(), this._geometry.linkAttributes(this._program);
+      const r = this._program.getProgram();
+      r && this._uniforms.attachProgram(r);
+    } catch (r) {
+      r instanceof u && this.options.onError(r);
+    }
+    return this;
+  }
+  /**
+   * Start animation loop.
+   */
+  play() {
+    return this.playing ? this : (this.playing = !0, this._clock.start(this.onRender), this);
+  }
+  /**
+   * Stop animation loop.
+   */
+  pause() {
+    if (!this.playing) return this;
+    const t = this._clock.getState();
+    return this.onBeforeHooks.run(t), this.playing = !1, this._clock.stop(), this.onAfterHooks.run(t), this;
+  }
+  /**
+   * Render a single frame.
+   */
+  render() {
+    return this.onRender(this._clock.getState()), this;
+  }
+  /**
+   * Get WebGL context.
+   */
+  getContext() {
+    return this.gl;
+  }
+  /**
+   * Get detected WebGL version.
+   */
+  getVersion() {
+    return this._version;
+  }
+  /**
+   * Cleanup all resources.
+   */
+  destroy() {
+    this.pause(), this._clock.destroy(), this._geometry.destroy(), this._program.destroy(), this._uniforms.destroy(), this.onAfterHooks.destroy(), this.onBeforeHooks.destroy();
+  }
+  /**
+   * Internal render callback.
+   */
+  onRender(t) {
+    const e = this.gl;
+    this.onBeforeHooks.run(t), e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), this._program.use(), this._uniforms.uploadBuiltIns(t, this._resolution, this._mouse), this._uniforms.uploadAll(), this._geometry.bind(), this._geometry.draw(), this.onAfterHooks.run(t);
+  }
+}
+const g = `#ifdef GL_ES
+precision mediump float;
+#endif
+
+attribute vec2 a_position;
+attribute vec2 a_texcoord;
+
+varying vec2 v_texcoord;
+
+void main() {
+  v_texcoord = a_texcoord;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`, A = `#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform vec2 u_resolution;
+uniform float u_time;
+
+varying vec2 v_texcoord;
+
+void main() {
+  vec2 uv = v_texcoord;
+  vec3 color = vec3(uv.x, uv.y, 0.5 + 0.5 * sin(u_time));
+  gl_FragColor = vec4(color, 1.0);
+}
+`, y = `#version 300 es
+
+in vec2 a_position;
+in vec2 a_texcoord;
+
+out vec2 v_texcoord;
+
+void main() {
+    v_texcoord = a_texcoord;
+    gl_Position = vec4(a_position, 0.0, 1.0);
+}`, M = `#version 300 es
+precision highp float;
+
+uniform vec2 u_resolution;
+uniform float u_time;
+uniform vec2 u_mouse;
+
+in vec2 v_texcoord;
+out vec4 fragColor;
+
+void main() {
+    vec2 uv = gl_FragCoord.xy / u_resolution;
+    vec3 color = vec3(uv.x, uv.y, 0.5 + 0.5 * sin(u_time));
+    fragColor = vec4(color, 1.0);
+}`;
+class E {
+  constructor(t, e) {
+    /** Active event listeners */
+    i(this, "listeners", []);
+    /** HTML canvas element */
+    i(this, "canvas");
+    /** Resolved options */
+    i(this, "options");
+    /** WebGL engine */
+    i(this, "engine");
+    this.canvas = t, this.options = this.resolveOptions(e), this.engine = _.setup(this.canvas, this.options), this.setupListeners(), this.setViewport(), this.options.onLoad(), this.options.autoplay && this.play();
+  }
+  /**
+   * Sandbox - A lightweight WebGL wrapper for shader effects.
+   *
+   * @example
+   * // Static rendering
+   * const sandbox = Sandbox.create(canvas, {
+   *   fragment: myShader,
+   *   autoplay: false,
+   * });
+   * sandbox.setUniforms({ u_time: 1.5 }).render();
+   *
+   * @example
+   * // Animation loop
+   * const sandbox = Sandbox.create(canvas, {
+   *   fragment: myShader,
+   *   autoplay: true,
+   * });
+   */
+  static create(t, e) {
+    return new E(t, e);
+  }
+  resolveOptions(t) {
+    const e = {
+      vertex: g,
+      fragment: A,
+      autoplay: !0,
+      pauseWhenHidden: !0,
+      dpr: "auto",
+      preserveDrawingBuffer: !1,
+      antialias: !0,
+      onError: (r) => {
+        console.error(
+          "Oops!",
+          r,
+          `
+You can handle errors programmatically by providing an onError callback to suppress this log and implement custom fallback behavior.`
+        );
+      },
+      onLoad: () => {
+      },
+      onBeforeRender: null,
+      onAfterRender: null,
+      uniforms: {}
+    };
+    if (t != null && t.vertex && !(t != null && t.fragment)) {
+      const r = h.detectVersion(t.vertex);
+      e.vertex = t.vertex, e.fragment = r === 2 ? M : A;
+    }
+    if (t != null && t.fragment && !(t != null && t.vertex)) {
+      const r = h.detectVersion(t.fragment);
+      e.fragment = t.fragment, e.vertex = r === 2 ? y : g;
+    }
+    return { ...e, ...t };
+  }
+  setupListeners() {
+    this.listeners.push(
+      // Window resize
+      l.on(window, "resize", () => {
+        this.setViewport();
+      }),
+      // Canvas resize
+      l.on(this.canvas, "resize", () => {
+        this.setViewport();
+      }),
+      // Visibility check on scroll
+      l.on(document, "scroll", () => {
+        this.options.pauseWhenHidden && (this.isInViewport() ? this.play() : this.pause());
+      }),
+      // Mouse tracking
+      l.on(document, "mousemove", (t) => {
+        this.setMouse(t.clientX || t.pageX, t.clientY || t.pageY);
+      }),
+      // Touch tracking
+      l.on(document, "touchmove", (t) => {
+        t.touches.length > 0 && this.setMouse(t.touches[0].clientX, t.touches[0].clientY);
+      })
+    );
+  }
+  destroyListeners() {
+    this.listeners.forEach((t) => t()), this.listeners = [];
+  }
+  setViewport() {
+    const t = this.options.dpr === "auto" ? Math.min(2, window.devicePixelRatio || 1) : this.options.dpr, e = this.canvas.clientWidth || this.canvas.width || 1, r = this.canvas.clientHeight || this.canvas.height || 1;
+    this.engine.viewport(
+      0,
+      0,
+      Math.max(1, Math.floor(e * t)),
+      Math.max(1, Math.floor(r * t))
+    );
+  }
+  isInViewport() {
+    const t = this.canvas.getBoundingClientRect();
+    return t.bottom >= 0 && t.right >= 0 && t.top <= (window.innerHeight || document.documentElement.clientHeight) && t.left <= (window.innerWidth || document.documentElement.clientWidth);
+  }
+  setMouse(t, e) {
+    const r = this.canvas.getBoundingClientRect();
+    t >= r.left && t <= r.right && e >= r.top && e <= r.bottom && this.engine.mouse(t - r.left, e - r.top);
+  }
+  /**
+   * Set a single uniform value with type checking.
+   * @example
+   * sandbox.setUniform<Vec3>("u_color", [1, 0, 0]);
+   * sandbox.setUniform<number>("u_time", 1.5);
+   * sandbox.setUniform<Vec3[]>("u_colors", [[1, 0, 0], [0, 1, 0]]);
+   */
+  setUniform(t, e) {
+    return this.engine.uniform(t, e), this;
+  }
+  /**
+   * Set multiple uniforms at once with type checking.
+   * @example
+   * interface MyUniforms extends UniformSchema {
+   *   u_time: number;
+   *   u_resolution: Vec2;
+   *   u_colors: Vec3[];
+   * }
+   * sandbox.setUniforms<MyUniforms>({
+   *   u_time: 1.5,
+   *   u_resolution: [800, 600],
+   *   u_colors: [[1, 0, 0], [0, 1, 0]],
+   * });
+   */
+  setUniforms(t) {
+    return this.engine.uniforms(t), this;
+  }
+  /**
+   * Get current uniform value.
+   */
+  getUniform(t) {
+    return this.engine.getUniform(t);
+  }
+  /**
+   * Update shaders.
+   * @example
+   * sandbox.setShader(vertexSource, fragmentSource);
+   */
+  setShader(t, e) {
+    return this.engine.shader(t, e), this;
+  }
+  /**
+   * Update only fragment shader (uses default vertex).
+   * @example
+   * sandbox.setFragment(fragmentSource);
+   */
+  setFragment(t) {
+    const r = this.webglVersion() === 1 ? g : y;
+    return this.engine.shader(r, t), this;
+  }
+  /**
+   * Add a runtime render hook.
+   */
+  hook(t, e = "before") {
+    return e === "before" ? this.engine.onBeforeHooks.add(t) : this.engine.onAfterHooks.add(t);
+  }
+  /**
+   * Start animation loop.
+   */
+  play() {
+    return this.engine.play(), this;
+  }
+  /**
+   * Start animation loop at specific time (in seconds).
+   */
+  playAt(t) {
+    return this.engine.clock(t), this.engine.play(), this;
+  }
+  /**
+   * Stop animation loop.
+   */
+  pause() {
+    return this.engine.pause(), this;
+  }
+  /**
+   * Pause animation loop at specific time (in seconds).
+   */
+  pauseAt(t) {
+    const e = this.hook((r) => {
+      r.time >= t && (e(), this.pause());
+    }, "after");
+    return this;
+  }
+  /**
+   * Toggle play/pause state.
+   */
+  toggle() {
+    return this.engine.playing ? this.pause() : this.play(), this;
+  }
+  /**
+   * Set current time (in seconds).
+   */
+  time(t) {
+    return this.engine.clock(t), this;
+  }
+  /**
+   * Render a single frame (for static rendering).
+   * @example
+   * sandbox.time(1.4).render();
+   */
+  render() {
+    return this.engine.render(), this;
+  }
+  /**
+   * Render at specific time (for deterministic output).
+   * @example
+   * sandbox.renderAt(2.5); // Render as if 2.5 seconds elapsed
+   */
+  renderAt(t) {
+    return this.engine.clock(t), this.engine.render(), this;
+  }
+  /**
+   * Check if currently playing.
+   */
+  isPlaying() {
+    return this.engine.playing;
+  }
+  /**
+   * Get WebGL version using (1 or 2).
+   */
+  webglVersion() {
+    return this.engine.getVersion();
+  }
+  /**
+   * Get canvas element.
+   */
+  canvasElement() {
+    return this.canvas;
+  }
+  /**
+   * Destroy sandbox and release all resources.
+   * @example
+   * onUnmounted(() => {
+   *   sandbox.destroy();
+   * });
+   */
+  destroy() {
+    this.destroyListeners(), this.engine.destroy();
+  }
+}
+export {
+  E as Sandbox,
+  w as SandboxContextError,
+  u as SandboxError,
+  m as SandboxProgramError,
+  f as SandboxShaderCompilationError,
+  k as SandboxShaderVersionMismatchError
+};