reel-deal 0.1.0-dev.0 → 0.1.0-dev.1

package/dist/index.es.js

@@ -0,0 +1,543 @@
+const b = {
+  minSpins: 2,
+  durationMs: 4e3,
+  speedPxS: 4e3,
+  staggerMs: 300
+}, y = {
+  warpAngleDeg: 90,
+  edgePower: 0.5
+}, I = {
+  maxPx: 4,
+  speedAtMax: 2200
+}, g = {
+  amplitudePx: 8,
+  speedHz: 0.25,
+  phaseOffsetRad: 0.9,
+  delayMs: 500,
+  rampMs: 800
+}, L = 0.1, x = 0.6, B = (a, e, i) => Math.max(e, Math.min(i, Math.floor(a))), P = (a, e) => (a % e + e) % e, v = (a) => Math.max(0, Math.min(1, a)), U = (a) => {
+  const e = v(a);
+  return e ** 2 * (2 - e);
+}, G = (a) => {
+  const e = v(a);
+  return e + e ** 2 - e ** 3;
+}, X = (a) => {
+  const e = v(a);
+  if (e <= L) {
+    const s = e / L;
+    return U(s) * L;
+  }
+  if (e < x)
+    return e;
+  const i = (e - x) / (1 - x);
+  return x + G(i) * (1 - x);
+}, E = (a, e) => typeof a == "number" && Number.isFinite(a) ? a : e, m = (a, e) => Math.max(0, E(a, e)), p = (a, e) => Math.max(0, Math.floor(E(a, e))), z = 2, D = (a) => {
+  const e = { ...b, ...a ?? {} };
+  return {
+    minSpins: p(e.minSpins, b.minSpins),
+    durationMs: p(e.durationMs, b.durationMs ?? 0),
+    speedPxS: p(e.speedPxS, b.speedPxS ?? 0),
+    staggerMs: p(e.staggerMs, b.staggerMs ?? 0)
+  };
+}, N = (a) => {
+  const e = { ...I, ...a ?? {} };
+  return {
+    maxPx: m(e.maxPx, I.maxPx),
+    speedAtMax: m(e.speedAtMax, I.speedAtMax)
+  };
+}, F = (a) => {
+  const e = { ...y, ...a ?? {} };
+  return {
+    warpAngleDeg: m(e.warpAngleDeg, y.warpAngleDeg),
+    edgePower: m(e.edgePower, y.edgePower)
+  };
+}, V = (a) => {
+  if (a === !1) return null;
+  const e = { ...g, ...a ?? {} };
+  return {
+    amplitudePx: m(e.amplitudePx, g.amplitudePx),
+    speedHz: m(e.speedHz, g.speedHz),
+    phaseOffsetRad: E(e.phaseOffsetRad, g.phaseOffsetRad),
+    delayMs: p(e.delayMs, g.delayMs),
+    rampMs: p(e.rampMs, g.rampMs)
+  };
+}, k = (a) => Math.max(1, E(a, z)), Y = (a, e) => {
+  const i = document.getElementById(a);
+  if (!i)
+    throw new Error(`${e} not found: ${a}`);
+  return i;
+}, H = (a, e) => typeof a == "string" ? Y(a, e) : a, q = 5, C = 0.72, $ = 0.28, Q = 7, W = 0.85, K = 1 - W;
+class j {
+  canvas;
+  container;
+  opts;
+  visibleSlots = 3;
+  heightScale = 2 / 3;
+  centerIndex = 1;
+  reels;
+  spinConfig;
+  spinBlur;
+  webglShading;
+  idleBob;
+  maxDpr;
+  spriteImg = null;
+  spriteWidth = 0;
+  spriteHeight = 0;
+  frameHeight = 0;
+  width = 0;
+  height = 0;
+  dpr = 1;
+  offsets;
+  velocities;
+  lastVelT = null;
+  lastVelOffsets;
+  idleStartTime = null;
+  idleBaseOffsets;
+  gl = null;
+  glProgram = null;
+  glBuffer = null;
+  glTexture = null;
+  glAttribs = null;
+  webglInitError = null;
+  glUniforms = null;
+  anim = null;
+  rafId = null;
+  pendingSpinResolvers = [];
+  resizeObserver = null;
+  resizeQueued = !1;
+  button = null;
+  buttonHandlerAttached = !1;
+  spinning = !1;
+  queuedSpins = null;
+  constructor(e) {
+    this.opts = e, this.reels = B(e.reels ?? 1, 1, q), this.spinConfig = D(e.spinConfig), this.spinBlur = N(e.spinBlur), this.webglShading = F(e.webglShading), this.idleBob = V(e.idleBob), this.maxDpr = k(e.maxDpr), this.canvas = H(e.canvas, "Canvas"), this.container = H(e.container, "Container"), this.offsets = new Array(this.reels).fill(0), this.velocities = new Array(this.reels).fill(0), this.lastVelOffsets = new Array(this.reels).fill(0), this.idleBaseOffsets = new Array(this.reels).fill(0);
+  }
+  async init() {
+    if (await this.loadSprite(), this.tryInitWebGL(), !this.gl)
+      throw new Error(
+        `WebGL is not supported or failed to initialize. ${this.webglInitError ?? ""}`.trim()
+      );
+    this.syncContainerLayoutVars(), this.ensureCanvasCoversContainer(), this.setupResizeWatcher(), this.resizeToContainer(), this.setSegments(this.opts.initialSegments), this.button = this.resolveButton(), this.queuedSpins = this.resolveSpinQueue(), this.attachButtonHandler(), this.render(), this.startLoop();
+  }
+  destroy() {
+    this.stop(), this.resizeObserver && (this.resizeObserver.disconnect(), this.resizeObserver = null), this.button && this.buttonHandlerAttached && (this.button.removeEventListener("click", this.handleButtonClick), this.buttonHandlerAttached = !1), this.releaseWebGLResources();
+  }
+  ensureCanvasCoversContainer() {
+    this.canvas !== this.container && this.container.contains(this.canvas) && (this.canvas.style.width || (this.canvas.style.width = "100%"), this.canvas.style.height || (this.canvas.style.height = "100%"), this.canvas.style.display || (this.canvas.style.display = "block"));
+  }
+  syncContainerLayoutVars() {
+    const e = this.canvas === this.container ? this.canvas : this.container;
+    e.style.setProperty("--reels", String(this.reels)), e.style.setProperty("--visible-slots", String(this.visibleSlots)), e.style.aspectRatio = `${this.reels} / ${this.visibleSlots * this.heightScale}`, this.canvas !== this.container && (this.container.style.overflow = "hidden");
+  }
+  setSegments(e) {
+    this.ensureReady();
+    const i = e ?? [];
+    for (let s = 0; s < this.reels; s += 1) {
+      const t = i[s] ?? 0, r = B(t, 0, this.opts.slotCount - 1);
+      this.offsets[s] = r * this.frameHeight - this.centerIndex * this.frameHeight, this.lastVelOffsets[s] = this.offsets[s], this.velocities[s] = 0, this.idleBaseOffsets[s] = this.offsets[s];
+    }
+    this.lastVelT = null, this.idleStartTime = null, this.anim = null, this.stop(), this.render(), this.startLoop();
+  }
+  setSegment(e) {
+    this.setSegments(new Array(this.reels).fill(e));
+  }
+  spinOnce(e, i) {
+    this.ensureReady();
+    const { minSpins: s, staggerMs: t, speedPxS: r, durationMs: o } = this.getSpinConfig(i), n = r > 0, c = new Array(this.reels), f = new Array(this.reels), u = new Array(this.reels);
+    for (let l = 0; l < this.reels; l += 1) {
+      const T = B(e[l] ?? 0, 0, this.opts.slotCount - 1) * this.frameHeight - this.centerIndex * this.frameHeight, A = P(T, this.spriteHeight), O = P(this.offsets[l], this.spriteHeight), w = P(O - A, this.spriteHeight);
+      let _ = -(s * this.spriteHeight + w);
+      if (n && o > 0) {
+        const M = r * o / 1e3, R = Math.max(
+          s,
+          Math.ceil(Math.max(0, M - w) / this.spriteHeight)
+        );
+        _ = -(w + R * this.spriteHeight);
+      }
+      if (t > 0 && n) {
+        const M = r * t * l / 1e3, R = Math.ceil(M / this.spriteHeight);
+        _ -= R * this.spriteHeight;
+      }
+      c[l] = this.offsets[l], f[l] = _, n ? u[l] = Math.max(0, Math.round(Math.abs(_) / r * 1e3)) : u[l] = Math.max(0, o + t * l);
+    }
+    if (f.reduce((l, S) => l + Math.abs(S), 0) === 0 || u.every((l) => l <= 0)) {
+      for (let l = 0; l < this.reels; l += 1)
+        this.offsets[l] = this.offsets[l] + f[l];
+      return this.anim = null, this.resolvePendingSpins(), this.render(), Promise.resolve();
+    }
+    const h = performance.now();
+    return this.anim = { startTime: h, startOffsets: c, deltas: f, durationMs: u }, this.idleStartTime = null, this.startLoop(), new Promise((l) => {
+      this.pendingSpinResolvers.push(l);
+    });
+  }
+  getSpinConfig(e) {
+    return e ? D({ ...this.spinConfig, ...e }) : this.spinConfig;
+  }
+  async spinQueue(e) {
+    for (let i = 0; i < e.length; i += 1) {
+      const s = e[i];
+      await this.spinOnce(s.stopAtSegments), s.callback?.(i, s.stopAtSegments);
+    }
+  }
+  stop() {
+    this.rafId !== null && cancelAnimationFrame(this.rafId), this.rafId = null, this.anim = null, this.resolvePendingSpins(), this.lastVelT = null;
+    for (let e = 0; e < this.reels; e += 1)
+      this.velocities[e] = 0;
+  }
+  resolvePendingSpins() {
+    if (this.pendingSpinResolvers.length === 0) return;
+    const e = this.pendingSpinResolvers;
+    this.pendingSpinResolvers = [];
+    for (const i of e)
+      i();
+  }
+  requestResize() {
+    this.queueResize();
+  }
+  ensureReady() {
+    if (!this.spriteImg || this.spriteWidth <= 0 || this.spriteHeight <= 0 || this.frameHeight <= 0)
+      throw new Error("Sprite is not ready. Call init() and await it first.");
+  }
+  attachButtonHandler() {
+    !this.button || this.buttonHandlerAttached || (this.button.addEventListener("click", this.handleButtonClick, { passive: !0 }), this.buttonHandlerAttached = !0);
+  }
+  handleButtonClick = async () => {
+    if (this.spinning) return;
+    const e = this.consumeNextSpin() ?? {
+      stopAtSegments: this.buildRandomSegments()
+    };
+    this.spinning = !0, this.setButtonDisabled(!0);
+    try {
+      await this.spinOnce(e.stopAtSegments);
+    } finally {
+      this.queuedSpins && this.queuedSpins.length === 0 ? this.setButtonDisabled(!0) : this.setButtonDisabled(!1), this.spinning = !1;
+    }
+  };
+  resolveButton() {
+    return this.opts.button ? H(this.opts.button, "Button") : null;
+  }
+  resolveSpinQueue() {
+    return this.opts.queuedSpinStates ?? null;
+  }
+  consumeNextSpin() {
+    return this.queuedSpins || (this.queuedSpins = this.resolveSpinQueue()), !this.queuedSpins || this.queuedSpins.length === 0 ? null : this.queuedSpins.shift() ?? null;
+  }
+  buildRandomSegments() {
+    const e = Math.max(1, Math.floor(this.opts.slotCount)), i = [];
+    for (let s = 0; s < this.reels; s += 1)
+      i.push(Math.floor(Math.random() * e));
+    return i;
+  }
+  setButtonDisabled(e) {
+    this.button && (this.button.disabled = e, e ? this.button.setAttribute("aria-busy", "true") : this.button.removeAttribute("aria-busy"));
+  }
+  shouldAnimate() {
+    return this.anim !== null || this.idleBob !== null;
+  }
+  startLoop() {
+    this.rafId === null && this.shouldAnimate() && (this.rafId = requestAnimationFrame(this.loop));
+  }
+  loop = (e) => {
+    if (this.anim) {
+      const { startTime: i, durationMs: s, startOffsets: t, deltas: r } = this.anim;
+      let o = !0;
+      for (let n = 0; n < this.reels; n += 1) {
+        const c = s[n] ?? 0, f = c <= 0 ? 1 : Math.min(1, (e - i) / c), u = X(f);
+        f < 1 && (o = !1);
+        const d = t[n] + r[n] * u;
+        let h = 0;
+        if (f > C && this.frameHeight > 0) {
+          const S = (1 - v((f - C) / $)) ** 2, T = d / this.frameHeight * Math.PI * 2, A = Math.min(Q, this.frameHeight * 0.06);
+          h = Math.sin(T) * S * A;
+        }
+        this.offsets[n] = d + h;
+      }
+      if (this.updateVelocity(e), this.render(), o) {
+        for (let n = 0; n < this.reels; n += 1)
+          this.offsets[n] = this.anim.startOffsets[n] + this.anim.deltas[n], this.idleBaseOffsets[n] = this.offsets[n];
+        this.updateVelocity(e);
+        for (let n = 0; n < this.reels; n += 1)
+          this.velocities[n] = 0;
+        this.anim = null, this.idleStartTime = null, this.render(), this.resolvePendingSpins();
+      }
+    } else this.idleBob && (this.updateIdle(e), this.render());
+    if (!this.shouldAnimate()) {
+      this.rafId = null;
+      return;
+    }
+    this.rafId !== null && (this.rafId = requestAnimationFrame(this.loop));
+  };
+  render() {
+    this.spriteImg && (this.width <= 0 || this.height <= 0 || this.gl && this.renderWebGL());
+  }
+  getSpinBlurPxForReel(e) {
+    if (!this.anim) return 0;
+    const i = Math.abs(this.velocities[e] ?? 0), s = Math.max(1, this.spinBlur.speedAtMax);
+    return v(i / s) * Math.max(0, this.spinBlur.maxPx);
+  }
+  renderWebGL() {
+    if (!this.gl || !this.glProgram || !this.glAttribs || !this.glUniforms || !this.glTexture || !this.glBuffer || !this.spriteImg) return;
+    const e = this.gl;
+    e.useProgram(this.glProgram), e.bindBuffer(e.ARRAY_BUFFER, this.glBuffer), e.enableVertexAttribArray(this.glAttribs.pos), e.vertexAttribPointer(this.glAttribs.pos, 2, e.FLOAT, !1, 16, 0), e.enableVertexAttribArray(this.glAttribs.uv), e.vertexAttribPointer(this.glAttribs.uv, 2, e.FLOAT, !1, 16, 8), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, this.glTexture), e.uniform1i(this.glUniforms.texture, 0), e.uniform1f(this.glUniforms.frameHeight, this.frameHeight), e.uniform1f(this.glUniforms.spriteHeight, this.spriteHeight), e.uniform1f(this.glUniforms.visibleSlots, this.visibleSlots), e.uniform1f(this.glUniforms.heightScale, this.heightScale), e.uniform1f(this.glUniforms.edgePower, Math.max(0.5, this.webglShading.edgePower));
+    const i = this.webglShading, s = Math.max(0, i.warpAngleDeg) * Math.PI / 180;
+    e.uniform1f(this.glUniforms.warpAngle, s), e.clear(e.COLOR_BUFFER_BIT);
+    const t = 1 / this.reels;
+    for (let r = 0; r < this.reels; r += 1) {
+      e.uniform1f(this.glUniforms.reelX, r * t), e.uniform1f(this.glUniforms.reelW, t);
+      const o = P(this.offsets[r], this.spriteHeight);
+      e.uniform1f(this.glUniforms.offsetPx, o), e.uniform1f(this.glUniforms.blurPx, this.getSpinBlurPxForReel(r)), e.drawArrays(e.TRIANGLE_STRIP, 0, 4);
+    }
+  }
+  updateVelocity(e) {
+    if (this.lastVelT === null) {
+      this.lastVelT = e;
+      for (let s = 0; s < this.reels; s += 1)
+        this.lastVelOffsets[s] = this.offsets[s], this.velocities[s] = 0;
+      return;
+    }
+    const i = (e - this.lastVelT) / 1e3;
+    if (!(i <= 0)) {
+      for (let s = 0; s < this.reels; s += 1) {
+        const t = (this.offsets[s] - this.lastVelOffsets[s]) / i;
+        this.velocities[s] = this.velocities[s] * W + t * K, this.lastVelOffsets[s] = this.offsets[s];
+      }
+      this.lastVelT = e;
+    }
+  }
+  updateIdle(e) {
+    if (!this.idleBob) return;
+    this.idleStartTime === null && (this.idleStartTime = e);
+    const { amplitudePx: i, speedHz: s, phaseOffsetRad: t, delayMs: r, rampMs: o } = this.idleBob, n = e - this.idleStartTime;
+    if (n < Math.max(0, r)) {
+      for (let h = 0; h < this.reels; h += 1)
+        this.offsets[h] = this.idleBaseOffsets[h], this.velocities[h] = 0;
+      return;
+    }
+    const c = (n - Math.max(0, r)) / 1e3, f = Math.max(
+      0,
+      Math.min(1, (n - Math.max(0, r)) / Math.max(1, o))
+    ), u = U(f), d = s * Math.PI * 2;
+    for (let h = 0; h < this.reels; h += 1) {
+      const l = c * d + h * t;
+      this.offsets[h] = this.idleBaseOffsets[h] + Math.sin(l) * (i * u), this.velocities[h] = 0;
+    }
+  }
+  async loadSprite() {
+    const { sprite: e } = this.opts, i = typeof e == "string" ? new Image() : e;
+    typeof e == "string" && (i.src = e), (!i.complete || i.naturalWidth <= 0) && await new Promise((f, u) => {
+      const d = () => f(), h = () => u(new Error("Failed to load sprite image"));
+      i.addEventListener("load", d, { once: !0 }), i.addEventListener("error", h, { once: !0 });
+    });
+    const s = Math.max(1, Math.floor(this.opts.slotCount)), t = i.naturalWidth, r = t, o = r * s, n = i.naturalHeight;
+    if (Math.abs(n - o) > 2)
+      throw new Error(
+        `Sprite size mismatch. Expected height ~${Math.round(o)}px (slotCount=${s}, slot aspect 1/1), got ${n}px.`
+      );
+    this.spriteImg = i, this.spriteWidth = t, this.frameHeight = Math.max(1, Math.round(r)), this.spriteHeight = Math.max(1, Math.round(this.frameHeight * s));
+  }
+  setupResizeWatcher() {
+    typeof ResizeObserver > "u" || this.resizeObserver || (this.resizeObserver = new ResizeObserver(() => this.queueResize()), this.resizeObserver.observe(this.container));
+  }
+  queueResize = () => {
+    this.resizeQueued || (this.resizeQueued = !0, requestAnimationFrame(() => {
+      this.resizeQueued = !1, this.resizeToContainer();
+    }));
+  };
+  resizeToContainer() {
+    const e = this.container.clientWidth, i = this.container.clientHeight, s = this.visibleSlots * this.heightScale;
+    if (e <= 0 || i <= 0) {
+      this.applyResize(1, 1);
+      return;
+    }
+    const t = s, r = this.reels, o = e / r * t;
+    let n = e, c = o;
+    c > i && (c = i, n = i / t * r);
+    const f = Math.max(1, Math.floor(n)), u = Math.max(1, Math.floor(c));
+    this.applyResize(f, u), this.render();
+  }
+  applyViewportCrop() {
+    this.canvas.style.width = "100%", this.canvas.style.height = "100%", this.canvas.style.transform = "";
+  }
+  applyResize(e, i) {
+    const s = Math.max(1, Math.floor(e)), t = Math.max(1, Math.floor(i)), r = this.getTargetDpr();
+    this.width = s, this.height = t, this.dpr = r, this.canvas.width = Math.floor(this.width * this.dpr), this.canvas.height = Math.floor(this.height * this.dpr), this.gl && this.gl.viewport(0, 0, this.canvas.width, this.canvas.height), this.applyViewportCrop();
+  }
+  getTargetDpr() {
+    const e = window.devicePixelRatio || 1, i = Math.max(1, e);
+    return Math.min(this.maxDpr, i);
+  }
+  tryInitWebGL() {
+    if (!this.spriteImg) return;
+    this.releaseWebGLResources(), this.webglInitError = null;
+    const e = this.canvas.getContext("webgl2", {
+      antialias: !0,
+      alpha: !0
+    }) ?? this.canvas.getContext("webgl", {
+      antialias: !0,
+      alpha: !0
+    }) ?? this.canvas.getContext("experimental-webgl", {
+      antialias: !0,
+      alpha: !0
+    });
+    if (!e) {
+      const u = document.createElement("canvas"), d = typeof WebGLRenderingContext < "u", h = u.getContext("webgl2") ?? u.getContext("webgl");
+      this.webglInitError = `context is null (browser WebGL=${d ? "yes" : "no"}, fallback canvas=${h ? "yes" : "no"})`, console.warn("ReelDeal WebGL:", this.webglInitError);
+      return;
+    }
+    const t = this.createWebGLProgram(e, `
+      attribute vec2 a_pos;
+      attribute vec2 a_uv;
+      varying vec2 v_uv;
+      void main() {
+        v_uv = a_uv;
+        gl_Position = vec4(a_pos, 0.0, 1.0);
+      }
+    `, `
+      #ifdef GL_FRAGMENT_PRECISION_HIGH
+      precision highp float;
+      #else
+      precision mediump float;
+      #endif
+
+      varying vec2 v_uv;
+      uniform sampler2D u_tex;
+      uniform float u_reelX;
+      uniform float u_reelW;
+      uniform float u_offsetPx;
+      uniform float u_frameHeight;
+      uniform float u_spriteHeight;
+      uniform float u_visibleSlots;
+      uniform float u_heightScale;
+      uniform float u_edgePower;
+      uniform float u_warpAngle;
+      uniform float u_blurPx;
+
+      float saturate(float x) { return clamp(x, 0.0, 1.0); }
+
+      void main() {
+        if (v_uv.x < u_reelX || v_uv.x > (u_reelX + u_reelW)) {
+          discard;
+        }
+
+        float localX = (v_uv.x - u_reelX) / u_reelW;
+        // v_uv.y is authored as 0 at TOP, 1 at BOTTOM (Canvas-like).
+        float localY = v_uv.y;
+        float hs = max(0.0001, u_heightScale);
+        float fullY = localY * hs + (1.0 - hs) * 0.5;
+
+        float warp = max(0.0, u_warpAngle);
+        float warpStrength = saturate(warp / 1.2);
+        float center = 0.5;
+        float centerBand = 1.0 / 3.0;
+        float halfBand = centerBand * 0.5;
+        float dist = abs(fullY - center);
+        // Smoother transition: avoid a hard boundary at halfBand.
+        float edgeWeight = smoothstep(halfBand, 0.5, dist);
+        float edgePow = max(0.5, u_edgePower);
+        edgeWeight = pow(edgeWeight, edgePow) * warpStrength;
+        float tEase = smoothstep(0.0, 1.0, fullY);
+        float warpedY = mix(fullY, tEase, edgeWeight);
+        float y = (warpedY - 0.5) * 2.0;
+        float theta = y * warp;
+        float edgeWarp = edgeWeight;
+
+        float yPx = u_offsetPx + warpedY * (u_frameHeight * u_visibleSlots);
+        // With UNPACK_FLIP_Y_WEBGL=0 and Canvas-like UVs (v=0 at TOP),
+        // v=0 samples the TOP of the original image, so pixel Y-from-top maps directly to v.
+        // Normalize early to improve precision on mobile GPUs.
+        float v = fract((u_offsetPx / u_spriteHeight) +
+                        warpedY * ((u_frameHeight * u_visibleSlots) / u_spriteHeight));
+
+        vec4 base = texture2D(u_tex, vec2(localX, v));
+
+        if (u_blurPx > 0.0) {
+          // Clamp blur step to reduce banding on mobile GPUs.
+          // Scale max step with speed proxy (u_blurPx).
+          float maxStepPx = 1.0 + 3.0 * saturate(u_blurPx / 4.0);
+          float blurPx = min(u_blurPx, maxStepPx);
+          float blurStep = blurPx / max(1.0, u_spriteHeight);
+          // 9-tap gaussian-ish blur to reduce banding on mobile.
+          vec4 sum = base * 0.227027;
+          sum += texture2D(u_tex, vec2(localX, fract(v + blurStep))) * 0.1945946;
+          sum += texture2D(u_tex, vec2(localX, fract(v - blurStep))) * 0.1945946;
+          sum += texture2D(u_tex, vec2(localX, fract(v + 2.0 * blurStep))) * 0.1216216;
+          sum += texture2D(u_tex, vec2(localX, fract(v - 2.0 * blurStep))) * 0.1216216;
+          sum += texture2D(u_tex, vec2(localX, fract(v + 3.0 * blurStep))) * 0.054054;
+          sum += texture2D(u_tex, vec2(localX, fract(v - 3.0 * blurStep))) * 0.054054;
+          sum += texture2D(u_tex, vec2(localX, fract(v + 4.0 * blurStep))) * 0.016216;
+          sum += texture2D(u_tex, vec2(localX, fract(v - 4.0 * blurStep))) * 0.016216;
+          base = sum;
+        }
+
+        gl_FragColor = base;
+      }
+    `);
+    if (!t) {
+      this.webglInitError = "shader program failed to compile/link (see console)", console.warn("ReelDeal WebGL:", this.webglInitError);
+      return;
+    }
+    const r = e.createBuffer();
+    if (!r) {
+      this.webglInitError = "failed to create vertex buffer", console.warn("ReelDeal WebGL:", this.webglInitError), e.deleteProgram(t);
+      return;
+    }
+    e.bindBuffer(e.ARRAY_BUFFER, r);
+    const o = new Float32Array([-1, -1, 0, 1, 1, -1, 1, 1, -1, 1, 0, 0, 1, 1, 1, 0]);
+    e.bufferData(e.ARRAY_BUFFER, o, e.STATIC_DRAW);
+    const n = e.createTexture();
+    if (!n) {
+      this.webglInitError = "failed to create texture", console.warn("ReelDeal WebGL:", this.webglInitError), e.deleteBuffer(r), e.deleteProgram(t);
+      return;
+    }
+    e.bindTexture(e.TEXTURE_2D, n), e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, 0), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, this.spriteImg);
+    const c = (u) => u > 0 && (u & u - 1) === 0;
+    c(this.spriteWidth) && c(this.spriteHeight) ? (e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.REPEAT), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.REPEAT), e.generateMipmap(e.TEXTURE_2D), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR)) : (e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE)), e.useProgram(t), e.clearColor(0, 0, 0, 0), e.enable(e.BLEND), e.blendFunc(e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA), this.gl = e, this.glProgram = t, this.glBuffer = r, this.glTexture = n, this.glAttribs = {
+      pos: e.getAttribLocation(t, "a_pos"),
+      uv: e.getAttribLocation(t, "a_uv")
+    }, this.glUniforms = {
+      texture: e.getUniformLocation(t, "u_tex"),
+      reelX: e.getUniformLocation(t, "u_reelX"),
+      reelW: e.getUniformLocation(t, "u_reelW"),
+      offsetPx: e.getUniformLocation(t, "u_offsetPx"),
+      frameHeight: e.getUniformLocation(t, "u_frameHeight"),
+      spriteHeight: e.getUniformLocation(t, "u_spriteHeight"),
+      visibleSlots: e.getUniformLocation(t, "u_visibleSlots"),
+      heightScale: e.getUniformLocation(t, "u_heightScale"),
+      edgePower: e.getUniformLocation(t, "u_edgePower"),
+      warpAngle: e.getUniformLocation(t, "u_warpAngle"),
+      blurPx: e.getUniformLocation(t, "u_blurPx")
+    };
+  }
+  createWebGLProgram(e, i, s) {
+    const t = this.createWebGLShader(e, e.VERTEX_SHADER, i), r = this.createWebGLShader(e, e.FRAGMENT_SHADER, s);
+    if (!t || !r)
+      return t && e.deleteShader(t), r && e.deleteShader(r), null;
+    const o = e.createProgram();
+    if (!o) return null;
+    if (e.attachShader(o, t), e.attachShader(o, r), e.linkProgram(o), !e.getProgramParameter(o, e.LINK_STATUS)) {
+      const n = e.getProgramInfoLog(o) ?? "unknown link error";
+      return this.webglInitError = `program link failed: ${n}`, console.warn("ReelDeal WebGL: program link failed", n), e.deleteProgram(o), e.deleteShader(t), e.deleteShader(r), null;
+    }
+    return e.detachShader(o, t), e.detachShader(o, r), e.deleteShader(t), e.deleteShader(r), o;
+  }
+  createWebGLShader(e, i, s) {
+    const t = e.createShader(i);
+    if (!t) return null;
+    if (e.shaderSource(t, s), e.compileShader(t), !e.getShaderParameter(t, e.COMPILE_STATUS)) {
+      const r = e.getShaderInfoLog(t) ?? "unknown compile error";
+      return this.webglInitError = `shader compile failed: ${r}`, console.warn("ReelDeal WebGL: shader compile failed", r), e.deleteShader(t), null;
+    }
+    return t;
+  }
+  releaseWebGLResources() {
+    this.gl && (this.glTexture && this.gl.deleteTexture(this.glTexture), this.glBuffer && this.gl.deleteBuffer(this.glBuffer), this.glProgram && this.gl.deleteProgram(this.glProgram), this.glTexture = null, this.glBuffer = null, this.glProgram = null, this.glAttribs = null, this.glUniforms = null, this.gl = null);
+  }
+}
+export {
+  j as ReelDeal,
+  g as defaultIdleBob,
+  I as defaultSpinBlur,
+  b as defaultSpinConfig,
+  y as defaultWebGLShading
+};
+//# sourceMappingURL=index.es.js.map