reel-deal 0.1.0-dev.0 → 0.1.0

package/dist/index.es.js

@@ -0,0 +1,554 @@
+const T = {
+  minSpins: 2,
+  durationMs: 4e3,
+  speedPxS: 4e3,
+  staggerMs: 300
+}, B = {
+  maxPx: 4,
+  speedAtMax: 2200
+}, E = {
+  amplitudePx: 9,
+  speedHz: 0.25,
+  phaseOffsetRad: 0.9,
+  rampMs: 800
+}, C = 0.1, A = 0.6, O = (a, t, s) => Math.max(t, Math.min(s, Math.floor(a))), I = (a, t) => (a % t + t) % t, v = (a) => Math.max(0, Math.min(1, a)), F = (a) => {
+  const t = v(a);
+  return t ** 2 * (2 - t);
+}, $ = (a) => {
+  const t = v(a);
+  return t + t ** 2 - t ** 3;
+}, Q = (a) => {
+  const t = v(a);
+  if (t <= C) {
+    const i = t / C;
+    return F(i) * C;
+  }
+  if (t < A)
+    return t;
+  const s = (t - A) / (1 - A);
+  return A + $(s) * (1 - A);
+}, L = (a, t) => typeof a == "number" && Number.isFinite(a) ? a : t, _ = (a, t) => Math.max(0, L(a, t)), R = (a, t) => Math.max(0, Math.floor(L(a, t))), K = 2, X = (a) => {
+  const t = { ...T, ...a ?? {} };
+  return {
+    minSpins: R(t.minSpins, T.minSpins),
+    durationMs: R(t.durationMs, T.durationMs ?? 0),
+    speedPxS: R(t.speedPxS, T.speedPxS ?? 0),
+    staggerMs: R(t.staggerMs, T.staggerMs ?? 0)
+  };
+}, Z = (a) => {
+  const t = { ...B, ...a ?? {} };
+  return {
+    maxPx: _(t.maxPx, B.maxPx),
+    speedAtMax: _(t.speedAtMax, B.speedAtMax)
+  };
+}, j = (a) => {
+  if (a === !1) return null;
+  const t = { ...E, ...a ?? {} };
+  return {
+    amplitudePx: _(t.amplitudePx, E.amplitudePx),
+    speedHz: _(t.speedHz, E.speedHz),
+    phaseOffsetRad: L(t.phaseOffsetRad, E.phaseOffsetRad),
+    rampMs: R(t.rampMs, E.rampMs)
+  };
+}, J = (a) => Math.max(1, L(a, K)), tt = (a, t) => {
+  const s = document.getElementById(a);
+  if (!s)
+    throw new Error(`${t} not found: ${a}`);
+  return s;
+}, U = (a, t) => typeof a == "string" ? tt(a, t) : a, et = 5, z = 0.72, st = 0.28, it = 7, V = 0.85, rt = 1 - V, nt = 30, at = 500, ot = 1.25, lt = 0.25, N = {
+  warpAngleDeg: 360,
+  edgePower: 0.5
+}, ht = (a) => ({
+  warpAngleDeg: _(a?.warpAngleDeg, N.warpAngleDeg),
+  edgePower: _(a?.edgePower, N.edgePower)
+});
+class ut {
+  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(t) {
+    this.opts = t, this.reels = O(t.reels ?? 1, 1, et), this.spinConfig = X(t.spinConfig), this.spinBlur = Z(t.spinBlur), this.webglShading = ht(
+      t.webglShading
+    ), this.idleBob = j(t.idleBob), this.maxDpr = J(t.maxDpr), this.canvas = U(t.canvas, "Canvas"), this.container = U(t.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 t = this.canvas === this.container ? this.canvas : this.container;
+    t.style.setProperty("--reels", String(this.reels)), t.style.setProperty("--visible-slots", String(this.visibleSlots)), t.style.aspectRatio = `${this.reels} / ${this.visibleSlots * this.heightScale}`, this.canvas !== this.container && (this.container.style.overflow = "hidden");
+  }
+  setSegments(t) {
+    this.ensureReady();
+    const s = t ?? [];
+    for (let i = 0; i < this.reels; i += 1) {
+      const e = s[i] ?? 0, r = O(e, 0, this.opts.slotCount - 1);
+      this.offsets[i] = r * this.frameHeight - this.centerIndex * this.frameHeight, this.lastVelOffsets[i] = this.offsets[i], this.velocities[i] = 0, this.idleBaseOffsets[i] = this.offsets[i];
+    }
+    this.lastVelT = null, this.idleStartTime = null, this.anim = null, this.stop(), this.render(), this.startLoop();
+  }
+  setSegment(t) {
+    this.setSegments(new Array(this.reels).fill(t));
+  }
+  spinOnce(t, s) {
+    this.ensureReady();
+    const { minSpins: i, staggerMs: e, speedPxS: r, durationMs: l } = this.getSpinConfig(s), u = r > 0, f = this.getStopSpringOvershootPx(), c = Math.max(0, at), n = c > 0 && f > 0, h = new Array(this.reels), g = new Array(this.reels), p = new Array(this.reels), d = new Array(this.reels), m = new Array(this.reels);
+    for (let o = 0; o < this.reels; o += 1) {
+      const k = O(t[o] ?? 0, 0, this.opts.slotCount - 1) * this.frameHeight - this.centerIndex * this.frameHeight, Y = I(k, this.spriteHeight), q = I(this.offsets[o], this.spriteHeight), H = I(q - Y, this.spriteHeight);
+      let x = -(i * this.spriteHeight + H);
+      if (u && l > 0) {
+        const M = r * l / 1e3, P = Math.max(
+          i,
+          Math.ceil(Math.max(0, M - H) / this.spriteHeight)
+        );
+        x = -(H + P * this.spriteHeight);
+      }
+      if (e > 0 && u) {
+        const M = r * e * o / 1e3, P = Math.ceil(M / this.spriteHeight);
+        x -= P * this.spriteHeight;
+      }
+      h[o] = this.offsets[o], m[o] = this.offsets[o] + x;
+      let D = x, G = 0;
+      if (n && x !== 0 && f > 0) {
+        const P = Math.sign(x) * f;
+        D += P, G = c;
+      }
+      g[o] = D, d[o] = G, u ? p[o] = Math.max(0, Math.round(Math.abs(D) / r * 1e3)) : p[o] = Math.max(0, l + e * o);
+    }
+    const S = g.reduce((o, w) => o + Math.abs(w), 0), b = p.every((o) => o <= 0), W = d.every((o) => o <= 0);
+    if (S === 0 || b && W) {
+      for (let o = 0; o < this.reels; o += 1)
+        this.offsets[o] = m[o];
+      return this.anim = null, this.resolvePendingSpins(), this.render(), Promise.resolve();
+    }
+    const y = performance.now();
+    return this.anim = {
+      startTime: y,
+      startOffsets: h,
+      deltas: g,
+      durationMs: p,
+      settleDurationMs: d,
+      targets: m
+    }, this.idleStartTime = null, this.startLoop(), new Promise((o) => {
+      this.pendingSpinResolvers.push(o);
+    });
+  }
+  getSpinConfig(t) {
+    return t ? X({ ...this.spinConfig, ...t }) : this.spinConfig;
+  }
+  getStopSpringOvershootPx() {
+    const t = this.frameHeight * lt, s = Math.max(0, nt);
+    return Math.min(s, t);
+  }
+  getStopSpringOffset(t, s) {
+    if (t === 0) return 0;
+    const i = Math.exp(-4 * s), e = Math.PI * 2 * ot * s;
+    return t * i * Math.cos(e);
+  }
+  async spinQueue(t) {
+    for (let s = 0; s < t.length; s += 1) {
+      const i = t[s];
+      await this.spinOnce(i.stopAtSegments), i.callback?.(s, i.stopAtSegments);
+    }
+  }
+  stop() {
+    this.rafId !== null && cancelAnimationFrame(this.rafId), this.rafId = null, this.anim = null, this.resolvePendingSpins(), this.lastVelT = null;
+    for (let t = 0; t < this.reels; t += 1)
+      this.velocities[t] = 0;
+  }
+  resolvePendingSpins() {
+    if (this.pendingSpinResolvers.length === 0) return;
+    const t = this.pendingSpinResolvers;
+    this.pendingSpinResolvers = [];
+    for (const s of t)
+      s();
+  }
+  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 t = this.consumeNextSpin() ?? {
+      stopAtSegments: this.buildRandomSegments()
+    };
+    this.spinning = !0, this.setButtonDisabled(!0);
+    try {
+      await this.spinOnce(t.stopAtSegments);
+    } finally {
+      this.queuedSpins && this.queuedSpins.length === 0 ? this.setButtonDisabled(!0) : this.setButtonDisabled(!1), this.spinning = !1;
+    }
+  };
+  resolveButton() {
+    return this.opts.button ? U(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 t = Math.max(1, Math.floor(this.opts.slotCount)), s = [];
+    for (let i = 0; i < this.reels; i += 1)
+      s.push(Math.floor(Math.random() * t));
+    return s;
+  }
+  setButtonDisabled(t) {
+    this.button && (this.button.disabled = t, t ? 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 = (t) => {
+    if (this.anim) {
+      const { startTime: s, durationMs: i, startOffsets: e, deltas: r, settleDurationMs: l, targets: u } = this.anim, f = t - s;
+      let c = !0;
+      for (let n = 0; n < this.reels; n += 1) {
+        const h = i[n] ?? 0, g = l[n] ?? 0, p = u[n] ?? e[n] + r[n];
+        if (h > 0 && f < h) {
+          const d = Math.min(1, f / h), m = Q(d);
+          d < 1 && (c = !1);
+          const S = e[n] + r[n] * m;
+          let b = 0;
+          if (d > z && this.frameHeight > 0) {
+            const y = (1 - v((d - z) / st)) ** 2, o = S / this.frameHeight * Math.PI * 2, w = Math.min(it, this.frameHeight * 0.06);
+            b = Math.sin(o) * y * w;
+          }
+          this.offsets[n] = S + b;
+        } else if (g > 0) {
+          const d = h <= 0 ? f / g : (f - h) / g, m = v(d), S = e[n] + r[n] - p, b = this.getStopSpringOffset(S, m);
+          m < 1 && (c = !1), this.offsets[n] = p + b;
+        } else
+          this.offsets[n] = p;
+      }
+      if (this.updateVelocity(t), this.render(), c) {
+        for (let n = 0; n < this.reels; n += 1) {
+          const h = this.anim.targets[n] ?? this.anim.startOffsets[n] + this.anim.deltas[n];
+          this.offsets[n] = h, this.idleBaseOffsets[n] = this.offsets[n];
+        }
+        this.updateVelocity(t);
+        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(t), 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(t) {
+    if (!this.anim) return 0;
+    const s = Math.abs(this.velocities[t] ?? 0), i = Math.max(1, this.spinBlur.speedAtMax);
+    return v(s / i) * Math.max(0, this.spinBlur.maxPx);
+  }
+  renderWebGL() {
+    if (!this.gl || !this.glProgram || !this.glAttribs || !this.glUniforms || !this.glTexture || !this.glBuffer || !this.spriteImg) return;
+    const t = this.gl;
+    t.useProgram(this.glProgram), t.bindBuffer(t.ARRAY_BUFFER, this.glBuffer), t.enableVertexAttribArray(this.glAttribs.pos), t.vertexAttribPointer(this.glAttribs.pos, 2, t.FLOAT, !1, 16, 0), t.enableVertexAttribArray(this.glAttribs.uv), t.vertexAttribPointer(this.glAttribs.uv, 2, t.FLOAT, !1, 16, 8), t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, this.glTexture), t.uniform1i(this.glUniforms.texture, 0), t.uniform1f(this.glUniforms.frameHeight, this.frameHeight), t.uniform1f(this.glUniforms.spriteHeight, this.spriteHeight), t.uniform1f(this.glUniforms.visibleSlots, this.visibleSlots), t.uniform1f(this.glUniforms.heightScale, this.heightScale), t.uniform1f(this.glUniforms.edgePower, Math.max(0.5, this.webglShading.edgePower));
+    const s = this.webglShading, i = Math.max(0, s.warpAngleDeg) * Math.PI / 180;
+    t.uniform1f(this.glUniforms.warpAngle, i), t.clear(t.COLOR_BUFFER_BIT);
+    const e = 1 / this.reels;
+    for (let r = 0; r < this.reels; r += 1) {
+      t.uniform1f(this.glUniforms.reelX, r * e), t.uniform1f(this.glUniforms.reelW, e);
+      const l = I(this.offsets[r], this.spriteHeight);
+      t.uniform1f(this.glUniforms.offsetPx, l), t.uniform1f(this.glUniforms.blurPx, this.getSpinBlurPxForReel(r)), t.drawArrays(t.TRIANGLE_STRIP, 0, 4);
+    }
+  }
+  updateVelocity(t) {
+    if (this.lastVelT === null) {
+      this.lastVelT = t;
+      for (let i = 0; i < this.reels; i += 1)
+        this.lastVelOffsets[i] = this.offsets[i], this.velocities[i] = 0;
+      return;
+    }
+    const s = (t - this.lastVelT) / 1e3;
+    if (!(s <= 0)) {
+      for (let i = 0; i < this.reels; i += 1) {
+        const e = (this.offsets[i] - this.lastVelOffsets[i]) / s;
+        this.velocities[i] = this.velocities[i] * V + e * rt, this.lastVelOffsets[i] = this.offsets[i];
+      }
+      this.lastVelT = t;
+    }
+  }
+  updateIdle(t) {
+    if (!this.idleBob) return;
+    this.idleStartTime === null && (this.idleStartTime = t);
+    const { amplitudePx: s, speedHz: i, phaseOffsetRad: e, rampMs: r } = this.idleBob, l = t - this.idleStartTime, u = l / 1e3, f = Math.max(0, Math.min(1, l / Math.max(1, r))), c = F(f), n = i * Math.PI * 2;
+    for (let h = 0; h < this.reels; h += 1) {
+      const g = u * n + h * e;
+      this.offsets[h] = this.idleBaseOffsets[h] + Math.sin(g) * (s * c), this.velocities[h] = 0;
+    }
+  }
+  async loadSprite() {
+    const { sprite: t } = this.opts, s = typeof t == "string" ? new Image() : t;
+    typeof t == "string" && (s.src = t), (!s.complete || s.naturalWidth <= 0) && await new Promise((c, n) => {
+      const h = () => c(), g = () => n(new Error("Failed to load sprite image"));
+      s.addEventListener("load", h, { once: !0 }), s.addEventListener("error", g, { once: !0 });
+    });
+    const i = Math.max(1, Math.floor(this.opts.slotCount)), e = s.naturalWidth, r = e, l = r * i, u = s.naturalHeight;
+    if (Math.abs(u - l) > 2)
+      throw new Error(
+        `Sprite size mismatch. Expected height ~${Math.round(l)}px (slotCount=${i}, slot aspect 1/1), got ${u}px.`
+      );
+    this.spriteImg = s, this.spriteWidth = e, this.frameHeight = Math.max(1, Math.round(r)), this.spriteHeight = Math.max(1, Math.round(this.frameHeight * i));
+  }
+  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 t = this.container.clientWidth, s = this.container.clientHeight, i = this.visibleSlots * this.heightScale;
+    if (t <= 0 || s <= 0) {
+      this.applyResize(1, 1);
+      return;
+    }
+    const e = i, r = this.reels, l = t / r * e;
+    let u = t, f = l;
+    f > s && (f = s, u = s / e * r);
+    const c = Math.max(1, Math.floor(u)), n = Math.max(1, Math.floor(f));
+    this.applyResize(c, n), this.render();
+  }
+  applyViewportCrop() {
+    this.canvas.style.width = "100%", this.canvas.style.height = "100%", this.canvas.style.transform = "";
+  }
+  applyResize(t, s) {
+    const i = Math.max(1, Math.floor(t)), e = Math.max(1, Math.floor(s)), r = this.getTargetDpr();
+    this.width = i, this.height = e, 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 t = window.devicePixelRatio || 1, s = Math.max(1, t);
+    return Math.min(this.maxDpr, s);
+  }
+  tryInitWebGL() {
+    if (!this.spriteImg) return;
+    this.releaseWebGLResources(), this.webglInitError = null;
+    const t = 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 (!t) {
+      const n = document.createElement("canvas"), h = typeof WebGLRenderingContext < "u", g = n.getContext("webgl2") ?? n.getContext("webgl");
+      this.webglInitError = `context is null (browser WebGL=${h ? "yes" : "no"}, fallback canvas=${g ? "yes" : "no"})`, console.warn("ReelDeal WebGL:", this.webglInitError);
+      return;
+    }
+    const e = this.createWebGLProgram(t, `
+      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;
+
+      const float HALF_PI = 1.5707963;
+
+      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;
+        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);
+        float edgeWeight = smoothstep(halfBand, 0.5, dist);
+        float edgePow = max(0.5, u_edgePower);
+        edgeWeight = pow(edgeWeight, edgePow) * warpStrength;
+        float yCentered = (fullY - 0.5) * 2.0;
+        float sinY = 0.5 + 0.5 * sin(yCentered * HALF_PI);
+        float warpedY = mix(fullY, sinY, edgeWeight);
+
+        float yPx = u_offsetPx + warpedY * (u_frameHeight * u_visibleSlots);
+        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) {
+          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);
+          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 (!e) {
+      this.webglInitError = "shader program failed to compile/link (see console)", console.warn("ReelDeal WebGL:", this.webglInitError);
+      return;
+    }
+    const r = t.createBuffer();
+    if (!r) {
+      this.webglInitError = "failed to create vertex buffer", console.warn("ReelDeal WebGL:", this.webglInitError), t.deleteProgram(e);
+      return;
+    }
+    t.bindBuffer(t.ARRAY_BUFFER, r);
+    const l = new Float32Array([-1, -1, 0, 1, 1, -1, 1, 1, -1, 1, 0, 0, 1, 1, 1, 0]);
+    t.bufferData(t.ARRAY_BUFFER, l, t.STATIC_DRAW);
+    const u = t.createTexture();
+    if (!u) {
+      this.webglInitError = "failed to create texture", console.warn("ReelDeal WebGL:", this.webglInitError), t.deleteBuffer(r), t.deleteProgram(e);
+      return;
+    }
+    t.bindTexture(t.TEXTURE_2D, u), t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, 0), t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, t.RGBA, t.UNSIGNED_BYTE, this.spriteImg);
+    const f = (n) => n > 0 && (n & n - 1) === 0;
+    f(this.spriteWidth) && f(this.spriteHeight) ? (t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.REPEAT), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.REPEAT), t.generateMipmap(t.TEXTURE_2D), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.LINEAR_MIPMAP_LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.LINEAR)) : (t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE)), t.useProgram(e), t.clearColor(0, 0, 0, 0), t.enable(t.BLEND), t.blendFunc(t.SRC_ALPHA, t.ONE_MINUS_SRC_ALPHA), this.gl = t, this.glProgram = e, this.glBuffer = r, this.glTexture = u, this.glAttribs = {
+      pos: t.getAttribLocation(e, "a_pos"),
+      uv: t.getAttribLocation(e, "a_uv")
+    }, this.glUniforms = {
+      texture: t.getUniformLocation(e, "u_tex"),
+      reelX: t.getUniformLocation(e, "u_reelX"),
+      reelW: t.getUniformLocation(e, "u_reelW"),
+      offsetPx: t.getUniformLocation(e, "u_offsetPx"),
+      frameHeight: t.getUniformLocation(e, "u_frameHeight"),
+      spriteHeight: t.getUniformLocation(e, "u_spriteHeight"),
+      visibleSlots: t.getUniformLocation(e, "u_visibleSlots"),
+      heightScale: t.getUniformLocation(e, "u_heightScale"),
+      edgePower: t.getUniformLocation(e, "u_edgePower"),
+      warpAngle: t.getUniformLocation(e, "u_warpAngle"),
+      blurPx: t.getUniformLocation(e, "u_blurPx")
+    };
+  }
+  createWebGLProgram(t, s, i) {
+    const e = this.createWebGLShader(t, t.VERTEX_SHADER, s), r = this.createWebGLShader(t, t.FRAGMENT_SHADER, i);
+    if (!e || !r)
+      return e && t.deleteShader(e), r && t.deleteShader(r), null;
+    const l = t.createProgram();
+    if (!l) return null;
+    if (t.attachShader(l, e), t.attachShader(l, r), t.linkProgram(l), !t.getProgramParameter(l, t.LINK_STATUS)) {
+      const u = t.getProgramInfoLog(l) ?? "unknown link error";
+      return this.webglInitError = `program link failed: ${u}`, console.warn("ReelDeal WebGL: program link failed", u), t.deleteProgram(l), t.deleteShader(e), t.deleteShader(r), null;
+    }
+    return t.detachShader(l, e), t.detachShader(l, r), t.deleteShader(e), t.deleteShader(r), l;
+  }
+  createWebGLShader(t, s, i) {
+    const e = t.createShader(s);
+    if (!e) return null;
+    if (t.shaderSource(e, i), t.compileShader(e), !t.getShaderParameter(e, t.COMPILE_STATUS)) {
+      const r = t.getShaderInfoLog(e) ?? "unknown compile error";
+      return this.webglInitError = `shader compile failed: ${r}`, console.warn("ReelDeal WebGL: shader compile failed", r), t.deleteShader(e), null;
+    }
+    return e;
+  }
+  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 {
+  ut as ReelDeal,
+  E as defaultIdleBob,
+  B as defaultSpinBlur,
+  T as defaultSpinConfig
+};
+//# sourceMappingURL=index.es.js.map