pixi-reels 0.1.0

package/dist/index.js

@@ -0,0 +1,1454 @@
+import { n as e, t } from "./SpineSymbol-D2jhCzFW.js";
+import { AnimatedSprite as n, Container as r, Graphics as i, Sprite as a } from "pixi.js";
+import { gsap as o } from "gsap";
+//#region src/events/EventEmitter.ts
+var s = class {
+	_listeners = /* @__PURE__ */ new Map();
+	on(e, t, n) {
+		return this._add(e, t, n, !1);
+	}
+	once(e, t, n) {
+		return this._add(e, t, n, !0);
+	}
+	off(e, t, n) {
+		let r = this._listeners.get(e);
+		if (!r) return this;
+		if (!t) return this._listeners.delete(e), this;
+		let i = r.filter((e) => e.fn !== t || n !== void 0 && e.context !== n);
+		return i.length === 0 ? this._listeners.delete(e) : this._listeners.set(e, i), this;
+	}
+	emit(e, ...t) {
+		let n = this._listeners.get(e);
+		if (!n || n.length === 0) return !1;
+		let r = n.slice();
+		for (let n of r) n.once && this.off(e, n.fn, n.context), n.fn.apply(n.context, t);
+		return !0;
+	}
+	removeAllListeners(e) {
+		return e === void 0 ? this._listeners.clear() : this._listeners.delete(e), this;
+	}
+	listenerCount(e) {
+		return this._listeners.get(e)?.length ?? 0;
+	}
+	_add(e, t, n, r) {
+		let i = this._listeners.get(e);
+		return i || (i = [], this._listeners.set(e, i)), i.push({
+			fn: t,
+			context: n,
+			once: r
+		}), this;
+	}
+}, c = class {
+	_symbolHeight;
+	_symbolGapY;
+	_slotHeight;
+	_minY;
+	_maxY;
+	constructor(e, t, n, r, i, a) {
+		this._symbols = e, this._bufferAbove = r, this._onSymbolWrapped = a, this._symbolHeight = t, this._symbolGapY = n, this._slotHeight = t + n, this._maxY = (i + 1) * this._slotHeight, this._minY = -(this._bufferAbove + 1) * this._slotHeight;
+	}
+	displace(e) {
+		if (e !== 0) {
+			for (let t of this._symbols) t.view.y += e;
+			e > 0 ? this._wrapBottomToTop() : this._wrapTopToBottom();
+		}
+	}
+	snapToGrid() {
+		for (let e = 0; e < this._symbols.length; e++) {
+			let t = (e - this._bufferAbove) * this._slotHeight;
+			this._symbols[e].view.y = t;
+		}
+	}
+	setToTopPosition() {
+		for (let e = 0; e < this._symbols.length; e++) this._symbols[e].view.y = this._minY - (this._symbols.length - e) * this._slotHeight;
+	}
+	getRowY(e) {
+		return (e - this._bufferAbove) * this._slotHeight;
+	}
+	get slotHeight() {
+		return this._slotHeight;
+	}
+	_wrapBottomToTop() {
+		let e = this._symbols.length - 1, t = this._symbols[e];
+		if (t.view.y < this._maxY) return;
+		let n = this._symbols[0];
+		t.view.y = n.view.y - this._slotHeight, this._symbols.pop(), this._symbols.unshift(t), this._onSymbolWrapped(t, 0, "up");
+	}
+	_wrapTopToBottom() {
+		let e = this._symbols[0];
+		if (e.view.y >= this._minY) return;
+		let t = this._symbols[this._symbols.length - 1];
+		e.view.y = t.view.y + this._slotHeight, this._symbols.shift(), this._symbols.push(e), this._onSymbolWrapped(e, this._symbols.length - 1, "down");
+	}
+}, l = class {
+	_frame = [];
+	_remaining = 0;
+	setFrame(e) {
+		this._frame = [...e], this._remaining = this._frame.length;
+	}
+	next() {
+		return this._remaining > 0 ? (this._remaining--, this._frame[this._remaining]) : this._frame[0] ?? "";
+	}
+	get hasRemaining() {
+		return this._remaining > 0;
+	}
+	get remaining() {
+		return this._remaining;
+	}
+	reset() {
+		this._frame = [], this._remaining = 0;
+	}
+}, u = class {
+	name = "standard";
+	computeDeltaY(e, t, n) {
+		let r = e * t * n / 1e3;
+		return Math.min(r, e / 2);
+	}
+}, d = class {
+	container;
+	events;
+	reelIndex;
+	symbols;
+	speed = 0;
+	spinningMode = new u();
+	motion;
+	stopSequencer;
+	_symbolFactory;
+	_randomProvider;
+	_viewport;
+	_symbolsData;
+	_visibleRows;
+	_bufferAbove;
+	_symbolWidth;
+	_symbolHeight;
+	_isDestroyed = !1;
+	_isStopping = !1;
+	constructor(e, t, n, i) {
+		this.reelIndex = e.reelIndex, this._symbolFactory = t, this._randomProvider = n, this._viewport = i, this._symbolsData = e.symbolsData, this._visibleRows = e.visibleRows, this._bufferAbove = e.bufferAbove, this._symbolWidth = e.symbolWidth, this._symbolHeight = e.symbolHeight, this.events = new s(), this.stopSequencer = new l(), this.container = new r(), this.container.sortableChildren = !0, this.container.x = e.reelIndex * (e.symbolWidth + e.symbolGapX), this.symbols = e.initialSymbols.map((n, r) => {
+			let i = t.acquire(n);
+			return i.resize(e.symbolWidth, e.symbolHeight), i;
+		}), this.motion = new c(this.symbols, e.symbolHeight, e.symbolGapY, e.bufferAbove, e.visibleRows, (e, t, n) => this._onSymbolWrapped(e, t, n)), this._setupSymbolPositions(e);
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	get isStopping() {
+		return this._isStopping;
+	}
+	set isStopping(e) {
+		this._isStopping = e;
+	}
+	get bufferAbove() {
+		return this._bufferAbove;
+	}
+	get bufferBelow() {
+		return this.symbols.length - this._bufferAbove - this._visibleRows;
+	}
+	get visibleRows() {
+		return this._visibleRows;
+	}
+	update(e) {
+		if (this.speed === 0) return;
+		let t = this.spinningMode.computeDeltaY(this.motion.slotHeight, this.speed, e);
+		t !== 0 && this.motion.displace(t);
+	}
+	setStopFrame(e) {
+		this.stopSequencer.setFrame(e);
+	}
+	getVisibleSymbols() {
+		let e = [];
+		for (let t = this._bufferAbove; t < this._bufferAbove + this._visibleRows; t++) e.push(this.symbols[t].symbolId);
+		return e;
+	}
+	getSymbolAt(e) {
+		return this.symbols[this._bufferAbove + e];
+	}
+	notifySpinStart() {
+		for (let e = this._bufferAbove; e < this._bufferAbove + this._visibleRows; e++) this.symbols[e].onReelSpinStart();
+	}
+	notifySpinEnd() {
+		for (let e = this._bufferAbove; e < this._bufferAbove + this._visibleRows; e++) this.symbols[e].onReelSpinEnd();
+	}
+	notifyLanded() {
+		for (let e = this._bufferAbove; e < this._bufferAbove + this._visibleRows; e++) this.symbols[e].onReelLanded();
+	}
+	snapToGrid() {
+		this.motion.snapToGrid(), this.refreshZIndex();
+	}
+	placeSymbols(e) {
+		let t = this.symbols.length;
+		for (let n = 0; n < t; n++) {
+			let t = n < this._bufferAbove ? this._randomProvider.next(!0) : n < this._bufferAbove + e.length ? e[n - this._bufferAbove] : this._randomProvider.next(!0);
+			this._replaceSymbol(n, t);
+		}
+		this.motion.snapToGrid(), this.refreshZIndex();
+	}
+	refreshZIndex() {
+		for (let e = 0; e < this.symbols.length; e++) {
+			let t = this.symbols[e], n = this._symbolsData[t.symbolId]?.zIndex ?? 0;
+			t.view.zIndex = n * 100 + e;
+		}
+	}
+	destroy() {
+		if (!this._isDestroyed) {
+			for (let e of this.symbols) this._symbolFactory.release(e);
+			this.symbols = [], this.events.removeAllListeners(), this.container.destroy({ children: !0 }), this._isDestroyed = !0, this.events.emit("destroyed");
+		}
+	}
+	_setupSymbolPositions(e) {
+		for (let t = 0; t < this.symbols.length; t++) {
+			let n = this.symbols[t], r = (t - e.bufferAbove) * (e.symbolHeight + e.symbolGapY);
+			n.view.y = r, n.view.x = 0, this.container.addChild(n.view);
+		}
+		this._viewport.maskedContainer.addChild(this.container);
+	}
+	_onSymbolWrapped(e, t, n) {
+		let r;
+		r = this._isStopping && this.stopSequencer.hasRemaining ? this.stopSequencer.next() : this._randomProvider.next(), this._replaceSymbol(this.symbols.indexOf(e), r), this.refreshZIndex();
+	}
+	_replaceSymbol(e, t) {
+		let n = this.symbols[e];
+		if (n.symbolId === t) {
+			n.view.alpha = 1, n.view.scale.set(1, 1), n.view.zIndex = 0;
+			return;
+		}
+		let r = n.view.parent, i = n.view.y;
+		this._symbolFactory.release(n);
+		let a = this._symbolFactory.acquire(t);
+		a.resize(this._symbolWidth, this._symbolHeight), a.view.y = i, a.view.x = 0, a.view.alpha = 1, a.view.scale.set(1, 1), a.view.zIndex = 0, r && r.addChild(a.view), this.symbols[e] = a, this.events.emit("symbol:created", t, e);
+	}
+}, f = class extends r {
+	maskedContainer;
+	unmaskedContainer;
+	spotlightContainer;
+	dimOverlay;
+	_mask;
+	_isDestroyed = !1;
+	constructor(e, t, n = {
+		x: 0,
+		y: 0
+	}) {
+		super(), this.x = n.x, this.y = n.y, this._mask = new i(), this._mask.rect(0, 0, e, t).fill({ color: 16777215 }), this.maskedContainer = new r(), this.maskedContainer.sortableChildren = !0, this.maskedContainer.addChild(this._mask), this.maskedContainer.mask = this._mask, this.addChild(this.maskedContainer), this.unmaskedContainer = new r(), this.unmaskedContainer.sortableChildren = !0, this.addChild(this.unmaskedContainer), this.dimOverlay = new i(), this.dimOverlay.rect(0, 0, e, t).fill({
+			color: 0,
+			alpha: .5
+		}), this.dimOverlay.visible = !1, this.addChild(this.dimOverlay), this.spotlightContainer = new r(), this.spotlightContainer.sortableChildren = !0, this.addChild(this.spotlightContainer);
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	showDim(e = .5) {
+		this.dimOverlay.alpha = e, this.dimOverlay.visible = !0;
+	}
+	hideDim() {
+		this.dimOverlay.visible = !1;
+	}
+	updateMaskSize(e, t) {
+		this._mask.clear(), this._mask.rect(0, 0, e, t).fill({ color: 16777215 });
+	}
+	destroy() {
+		this._isDestroyed || (this._isDestroyed = !0, super.destroy({ children: !0 }));
+	}
+}, p = class {
+	_reel;
+	_speed;
+	_resolve = null;
+	_isActive = !1;
+	constructor(e, t) {
+		this._reel = e, this._speed = t;
+	}
+	get reel() {
+		return this._reel;
+	}
+	get isActive() {
+		return this._isActive;
+	}
+	async run(e) {
+		return this._isActive = !0, this._reel.events.emit("phase:enter", this.name), new Promise((t) => {
+			this._resolve = () => {
+				this._isActive = !1, this._reel.events.emit("phase:exit", this.name), t();
+			}, this.onEnter(e);
+		});
+	}
+	skip() {
+		!this.skippable || !this._isActive || (this.onSkip(), this._complete());
+	}
+	forceComplete() {
+		this._isActive && (this.onSkip(), this._complete());
+	}
+	_complete() {
+		if (this._resolve) {
+			let e = this._resolve;
+			this._resolve = null, e();
+		}
+	}
+}, m = class extends p {
+	name = "start";
+	skippable = !0;
+	_tween = null;
+	_delayedCall = null;
+	onEnter(e) {
+		let t = this._reel;
+		this._speed;
+		let n = e.delay ?? 0;
+		t.spinningMode = e.spinningMode, t.speed = 0, n > 0 ? this._delayedCall = o.delayedCall(n / 1e3, () => this._launch()) : this._launch();
+	}
+	_launch() {
+		this._delayedCall = null;
+		let e = this._reel, t = this._speed, n = (t.accelerationDuration ?? 300) / 1e3, r = t.accelerationEase ?? "power2.in";
+		this._tween = o.timeline(), t.bounceDistance > 0 && this._tween.to(e, {
+			speed: -2,
+			duration: .05,
+			ease: "power1.out"
+		}), this._tween.to(e, {
+			speed: t.spinSpeed,
+			duration: n,
+			ease: r,
+			onComplete: () => {
+				e.notifySpinStart(), this._complete();
+			}
+		});
+	}
+	update(e) {}
+	onSkip() {
+		this._kill(), this._reel.speed = this._speed.spinSpeed;
+	}
+	_kill() {
+		this._delayedCall &&= (this._delayedCall.kill(), null), this._tween &&= (this._tween.kill(), null);
+	}
+}, h = class extends p {
+	name = "spin";
+	skippable = !1;
+	_elapsed = 0;
+	_minTime = 0;
+	_readyToStop = !1;
+	onEnter(e) {
+		this._elapsed = 0, this._minTime = e.minimumSpinTime ?? this._speed.minimumSpinTime ?? 500, this._readyToStop = !1;
+	}
+	update(e) {
+		this._elapsed += e, this._readyToStop && this._elapsed >= this._minTime && this._complete();
+	}
+	resolve() {
+		this._readyToStop = !0, this._elapsed >= this._minTime && this._complete();
+	}
+	onSkip() {}
+}, g = class extends p {
+	name = "stop";
+	skippable = !0;
+	_config = null;
+	_delayTween = null;
+	_bounceTween = null;
+	_stage = "delay";
+	_baseY = 0;
+	onEnter(e) {
+		this._config = e, this._stage = "delay", this._baseY = this._reel.container.y;
+		let t = (e.delay ?? 0) / 1e3;
+		t > 0 ? this._delayTween = o.delayedCall(t, () => this._beginSpinOut()) : this._beginSpinOut();
+	}
+	_beginSpinOut() {
+		if (!this._config) return;
+		let e = this._reel, t = this._speed;
+		e.setStopFrame(this._config.targetFrame), e.isStopping = !0, e.speed = t.spinSpeed, this._stage = "spinning";
+	}
+	update(e) {
+		this._stage === "spinning" && (this._reel.stopSequencer.hasRemaining || this._landAndBounce());
+	}
+	_landAndBounce() {
+		let e = this._reel, t = this._speed;
+		e.speed = 0, e.isStopping = !1, e.snapToGrid(), e.notifySpinEnd(), e.notifyLanded();
+		let n = t.bounceDistance;
+		if (n <= 0) {
+			this._stage = "done", this._complete();
+			return;
+		}
+		let r = (t.bounceDuration ?? 600) / 2e3;
+		this._stage = "bouncing", this._bounceTween = o.timeline(), this._bounceTween.to(e.container, {
+			y: this._baseY + n,
+			duration: r,
+			ease: "power1.out"
+		}), this._bounceTween.to(e.container, {
+			y: this._baseY,
+			duration: r,
+			ease: "power1.out",
+			onComplete: () => {
+				this._stage = "done", this._complete();
+			}
+		});
+	}
+	onSkip() {
+		this._killTweens();
+		let e = this._reel;
+		if (e.speed = 0, e.isStopping = !1, this._stage !== "done" && this._config) {
+			let t = e.bufferAbove, n = e.visibleRows;
+			e.placeSymbols(this._config.targetFrame.slice(t, t + n));
+		}
+		e.snapToGrid(), e.container.y = this._baseY, e.notifySpinEnd(), e.notifyLanded(), this._stage = "done";
+	}
+	_killTweens() {
+		this._delayTween &&= (this._delayTween.kill(), null), this._bounceTween &&= (this._bounceTween.kill(), null);
+	}
+}, _ = class extends p {
+	name = "anticipation";
+	skippable = !0;
+	_tween = null;
+	onEnter(e) {
+		let t = this._reel, n = this._speed, r = (e.duration ?? n.anticipationDelay) / 1e3, i = n.spinSpeed * (e.speedMultiplier ?? .3);
+		if (r <= 0) {
+			this._complete();
+			return;
+		}
+		this._tween = o.timeline(), this._tween.to(t, {
+			speed: i,
+			duration: r * .35,
+			ease: "power2.out"
+		}), this._tween.to({}, {
+			duration: r * .65,
+			onComplete: () => this._complete()
+		});
+	}
+	update(e) {}
+	onSkip() {
+		this._kill(), this._reel.speed = this._speed.spinSpeed;
+	}
+	_kill() {
+		this._tween &&= (this._tween.kill(), null);
+	}
+}, v = class {
+	_registry = /* @__PURE__ */ new Map();
+	constructor() {
+		this._registry.set("start", m), this._registry.set("spin", h), this._registry.set("stop", g), this._registry.set("anticipation", _);
+	}
+	register(e, t) {
+		this._registry.set(e, t);
+	}
+	create(e, t, n) {
+		let r = this._registry.get(e);
+		if (!r) throw Error(`Phase '${e}' not registered. Available: ${[...this._registry.keys()].join(", ")}`);
+		return new r(t, n);
+	}
+	has(e) {
+		return this._registry.has(e);
+	}
+}, y = class {
+	_callbacks = [];
+	_isDestroyed = !1;
+	constructor(e) {
+		this._ticker = e;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	add(e) {
+		this._isDestroyed || (this._callbacks.push(e), this._ticker.add(e));
+	}
+	remove(e) {
+		let t = this._callbacks.indexOf(e);
+		t !== -1 && (this._callbacks.splice(t, 1), this._ticker.remove(e));
+	}
+	destroy() {
+		if (!this._isDestroyed) {
+			for (let e of this._callbacks) this._ticker.remove(e);
+			this._callbacks.length = 0, this._isDestroyed = !0;
+		}
+	}
+}, b = class {
+	_reels;
+	_speedManager;
+	_frameBuilder;
+	_phaseFactory;
+	_events;
+	_tickerRef;
+	_spinningMode;
+	_isSpinning = !1;
+	_spinStartTime = 0;
+	_resultSymbols = null;
+	_anticipationReels = [];
+	_stopDelayOverride = null;
+	_activePhases = /* @__PURE__ */ new Map();
+	_landedReels = /* @__PURE__ */ new Set();
+	_wasSkipped = !1;
+	_isDestroyed = !1;
+	_currentSpinResolve = null;
+	_spinGeneration = 0;
+	constructor(e, t, n, r, i, a, o) {
+		this._reels = e, this._speedManager = t, this._frameBuilder = n, this._phaseFactory = r, this._events = i, this._tickerRef = new y(a), this._spinningMode = o ?? new u(), this._tickerRef.add((e) => this._onTick(e));
+	}
+	get isSpinning() {
+		return this._isSpinning;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	async spin() {
+		if (this._isSpinning) throw Error("Cannot start a new spin while one is in progress.");
+		this._isSpinning = !0, this._wasSkipped = !1, this._spinStartTime = performance.now(), this._resultSymbols = null, this._anticipationReels = [], this._stopDelayOverride = null, this._landedReels.clear(), this._activePhases.clear(), this._spinGeneration++;
+		let e = this._spinGeneration, t = this._speedManager.active;
+		this._events.emit("spin:start");
+		let n = new Promise((e) => {
+			this._currentSpinResolve = e;
+		});
+		for (let n = 0; n < this._reels.length; n++) this._startReel(n, t, e);
+		return n;
+	}
+	setResult(e) {
+		this._isSpinning && (this._resultSymbols = e, this._tryBeginStopSequence());
+	}
+	setAnticipation(e) {
+		this._anticipationReels = e;
+	}
+	setStopDelays(e) {
+		this._stopDelayOverride = [...e];
+	}
+	skip() {
+		if (this._isSpinning) {
+			this._wasSkipped = !0, this._events.emit("skip:requested");
+			for (let [, e] of this._activePhases) e.forceComplete();
+			if (this._activePhases.clear(), this._spinGeneration++, this._resultSymbols) for (let e = 0; e < this._reels.length; e++) {
+				if (this._landedReels.has(e)) continue;
+				let t = this._reels[e];
+				t.speed = 0, t.isStopping = !1, t.placeSymbols(this._resultSymbols[e]), this._markLanded(e);
+			}
+			else for (let e = 0; e < this._reels.length; e++) {
+				if (this._landedReels.has(e)) continue;
+				let t = this._reels[e];
+				t.speed = 0, t.isStopping = !1, t.snapToGrid(), this._markLanded(e);
+			}
+			this._events.emit("skip:completed");
+		}
+	}
+	destroy() {
+		this._isDestroyed ||= (this._tickerRef.destroy(), this._activePhases.clear(), !0);
+	}
+	async _startReel(e, t, n) {
+		if (n !== this._spinGeneration) return;
+		let r = this._reels[e], i = this._phaseFactory.create("start", r, t);
+		if (this._activePhases.set(e, i), await i.run({
+			spinningMode: this._spinningMode,
+			delay: e * t.spinDelay
+		}), n !== this._spinGeneration) return;
+		let a = this._phaseFactory.create("spin", r, t);
+		this._activePhases.set(e, a);
+		let o = a.run({}), s = !0;
+		for (let e = 0; e < this._reels.length; e++) {
+			let t = this._activePhases.get(e);
+			if (!t || t.name !== "spin") {
+				s = !1;
+				break;
+			}
+		}
+		if (s && (this._events.emit("spin:allStarted"), this._tryBeginStopSequence()), await o, n !== this._spinGeneration) return;
+		let c = this._stopDelayFor(e, t), l = this._frameFor(e);
+		if (this._anticipationReels.includes(e) && t.anticipationDelay > 0) {
+			this._events.emit("spin:stopping", e);
+			let i = this._phaseFactory.create("anticipation", r, t);
+			if (this._activePhases.set(e, i), await i.run({}), n !== this._spinGeneration) return;
+		} else this._events.emit("spin:stopping", e);
+		let u = this._phaseFactory.create("stop", r, t);
+		this._activePhases.set(e, u), await u.run({
+			targetFrame: l,
+			delay: c
+		}), n === this._spinGeneration && this._markLanded(e);
+	}
+	_stopDelayFor(e, t) {
+		return this._stopDelayOverride ? this._stopDelayOverride[e] ?? 0 : e * t.stopDelay;
+	}
+	_cachedFrames = null;
+	_frameFor(e) {
+		return this._cachedFrames ? this._cachedFrames[e] : [];
+	}
+	_tryBeginStopSequence() {
+		if (!this._resultSymbols) return;
+		for (let e = 0; e < this._reels.length; e++) {
+			let t = this._activePhases.get(e);
+			if (!t || t.name !== "spin") return;
+		}
+		let e = [];
+		for (let t = 0; t < this._reels.length; t++) {
+			let n = this._reels[t];
+			e.push(this._frameBuilder.build(t, n.visibleRows, n.bufferAbove, n.bufferBelow, this._resultSymbols[t]));
+		}
+		this._cachedFrames = e;
+		for (let e = 0; e < this._reels.length; e++) {
+			let t = this._activePhases.get(e);
+			t?.resolve && t.resolve();
+		}
+	}
+	_markLanded(e) {
+		if (this._landedReels.has(e)) return;
+		this._landedReels.add(e);
+		let t = this._reels[e], n = t.getVisibleSymbols();
+		t.events.emit("landed", n), this._events.emit("spin:reelLanded", e, n), this._landedReels.size === this._reels.length && this._finishSpin();
+	}
+	_finishSpin() {
+		let e = {
+			symbols: this._reels.map((e) => e.getVisibleSymbols()),
+			wasSkipped: this._wasSkipped,
+			duration: performance.now() - this._spinStartTime
+		};
+		this._isSpinning = !1, this._activePhases.clear(), this._cachedFrames = null, this._events.emit("spin:allLanded", e), this._events.emit("spin:complete", e), this._currentSpinResolve &&= (this._currentSpinResolve(e), null);
+	}
+	_onTick(e) {
+		if (!this._isSpinning) return;
+		let t = e.deltaMS;
+		for (let e of this._reels) e.update(t);
+		for (let e of this._activePhases.values()) e.isActive && e.update(t);
+	}
+}, x = class {
+	_profiles = /* @__PURE__ */ new Map();
+	_activeName;
+	_active;
+	constructor(e, t) {
+		for (let [t, n] of e) this._profiles.set(t, n);
+		let n = this._profiles.get(t);
+		if (!n) throw Error(`Speed profile '${t}' not found. Available: ${[...this._profiles.keys()].join(", ")}`);
+		this._activeName = t, this._active = n;
+	}
+	get active() {
+		return this._active;
+	}
+	get activeName() {
+		return this._activeName;
+	}
+	set(e) {
+		let t = this._profiles.get(e);
+		if (!t) throw Error(`Speed profile '${e}' not found. Available: ${[...this._profiles.keys()].join(", ")}`);
+		let n = this._active;
+		return this._activeName = e, this._active = t, {
+			previous: n,
+			current: t
+		};
+	}
+	addProfile(e, t) {
+		this._profiles.set(e, t);
+	}
+	getProfile(e) {
+		return this._profiles.get(e);
+	}
+	get profileNames() {
+		return [...this._profiles.keys()];
+	}
+}, S = class {
+	_reels;
+	_viewport;
+	_promoted = [];
+	_isActive = !1;
+	_isDestroyed = !1;
+	_cycleAbort = null;
+	constructor(e, t) {
+		this._reels = e, this._viewport = t;
+	}
+	get isActive() {
+		return this._isActive;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	async show(e, t = {}) {
+		this.hide();
+		let { dimAmount: n = .5, playWinAnimation: r = !0, promoteAboveMask: i = !0 } = t;
+		this._isActive = !0, this._viewport.showDim(n);
+		let a = [];
+		for (let t of e) {
+			let e = this._reels[t.reelIndex];
+			if (!e) continue;
+			let n = e.getSymbolAt(t.rowIndex);
+			if (!n) continue;
+			let o = n.view.parent;
+			if (this._promoted.push({
+				symbol: n,
+				originalParent: o,
+				position: t
+			}), i) {
+				let e = n.view.getGlobalPosition();
+				this._viewport.spotlightContainer.addChild(n.view);
+				let t = this._viewport.spotlightContainer.toLocal(e);
+				n.view.x = t.x, n.view.y = t.y;
+			}
+			r && a.push(n.playWin());
+		}
+		a.length > 0 && await Promise.all(a);
+	}
+	hide() {
+		this._cycleAbort &&= (this._cycleAbort.abort(), null);
+		for (let { symbol: e, originalParent: t } of this._promoted) {
+			if (t && e.view.parent !== t) {
+				let n = e.view.getGlobalPosition();
+				t.addChild(e.view);
+				let r = t.toLocal(n);
+				e.view.x = r.x, e.view.y = r.y;
+			}
+			e.stopAnimation();
+		}
+		this._promoted = [], this._viewport.hideDim(), this._isActive = !1;
+	}
+	async cycle(e, t = {}) {
+		let { displayDuration: n = 2e3, gapDuration: r = 300, cycles: i = 1 } = t;
+		if (e.length === 0) return;
+		this._cycleAbort = new AbortController();
+		let a = this._cycleAbort.signal, o = 0;
+		for (; i === -1 || o < i;) {
+			for (let i of e) {
+				if (a.aborted || (await this.show(i.positions, t), await this._wait(n, a), a.aborted)) return;
+				this.hide(), await this._wait(r, a);
+			}
+			o++;
+		}
+	}
+	destroy() {
+		this._isDestroyed ||= (this.hide(), !0);
+	}
+	_wait(e, t) {
+		return new Promise((n) => {
+			if (t.aborted) {
+				n();
+				return;
+			}
+			let r = setTimeout(n, e);
+			t.addEventListener("abort", () => {
+				clearTimeout(r), n();
+			}, { once: !0 });
+		});
+	}
+}, C = class extends r {
+	_events = new s();
+	_reels;
+	_viewport;
+	_spinController;
+	_speedManager;
+	_spotlight;
+	_symbolFactory;
+	_isDestroyed = !1;
+	constructor(e) {
+		super(), this._reels = e.reels, this._viewport = e.viewport, this._symbolFactory = e.symbolFactory, this._speedManager = new x(e.config.speeds, e.config.initialSpeed), this._spinController = new b(e.reels, this._speedManager, e.frameBuilder, e.phaseFactory, this._events, e.config.ticker, e.spinningMode), this._spotlight = new S(e.reels, e.viewport), this.addChild(this._viewport);
+	}
+	get events() {
+		return this._events;
+	}
+	async spin() {
+		return this._spinController.spin();
+	}
+	setResult(e) {
+		this._spinController.setResult(e);
+	}
+	setAnticipation(e) {
+		this._spinController.setAnticipation(e);
+	}
+	setStopDelays(e) {
+		this._spinController.setStopDelays(e);
+	}
+	skip() {
+		this._spinController.skip();
+	}
+	get isSpinning() {
+		return this._spinController.isSpinning;
+	}
+	get speed() {
+		return this._speedManager;
+	}
+	setSpeed(e) {
+		let { previous: t, current: n } = this._speedManager.set(e);
+		this._events.emit("speed:changed", n, t);
+	}
+	get spotlight() {
+		return this._spotlight;
+	}
+	get reels() {
+		return this._reels;
+	}
+	getReel(e) {
+		return this._reels[e];
+	}
+	get viewport() {
+		return this._viewport;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	destroy() {
+		if (!this._isDestroyed) {
+			this._isDestroyed = !0, this._spotlight.destroy(), this._spinController.destroy();
+			for (let e of this._reels) e.destroy();
+			this._symbolFactory.destroy(), this._viewport.destroy(), this._events.emit("destroyed"), this._events.removeAllListeners(), super.destroy({ children: !0 });
+		}
+	}
+}, w = {
+	bufferSymbols: 1,
+	symbolGap: {
+		x: 0,
+		y: 0
+	},
+	initialSpeed: "normal",
+	maxPoolPerKey: 20,
+	zIndexStep: 100
+}, T = {
+	NORMAL: {
+		name: "normal",
+		spinDelay: 100,
+		spinSpeed: 30,
+		stopDelay: 140,
+		anticipationDelay: 450,
+		bounceDistance: 56,
+		bounceDuration: 600,
+		accelerationEase: "power2.in",
+		decelerationEase: "power2.out",
+		accelerationDuration: 300,
+		minimumSpinTime: 500
+	},
+	TURBO: {
+		name: "turbo",
+		spinDelay: 30,
+		spinSpeed: 50,
+		stopDelay: 0,
+		anticipationDelay: 250,
+		bounceDistance: 42,
+		bounceDuration: 200,
+		accelerationEase: "power2.in",
+		decelerationEase: "power2.out",
+		accelerationDuration: 200,
+		minimumSpinTime: 300
+	},
+	SUPER_TURBO: {
+		name: "superTurbo",
+		spinDelay: 0,
+		spinSpeed: 80,
+		stopDelay: 0,
+		anticipationDelay: 0,
+		bounceDistance: 14,
+		bounceDuration: 120,
+		accelerationEase: "power1.in",
+		decelerationEase: "power1.out",
+		accelerationDuration: 50,
+		minimumSpinTime: 100
+	}
+}, E = class {
+	_entries = /* @__PURE__ */ new Map();
+	register(e, t, n) {
+		if (this._entries.has(e)) throw Error(`Symbol '${e}' is already registered.`);
+		this._entries.set(e, {
+			SymbolClass: t,
+			options: n
+		});
+	}
+	create(e) {
+		let t = this._entries.get(e);
+		if (!t) throw Error(`Symbol '${e}' is not registered. Available: ${[...this._entries.keys()].join(", ")}`);
+		let n = new t.SymbolClass(t.options);
+		return n.activate(e), n;
+	}
+	has(e) {
+		return this._entries.has(e);
+	}
+	get symbolIds() {
+		return [...this._entries.keys()];
+	}
+	get size() {
+		return this._entries.size;
+	}
+}, D = class {
+	_pools = /* @__PURE__ */ new Map();
+	_isDestroyed = !1;
+	constructor(e, t, n, r = 20) {
+		this._factory = e, this._reset = t, this._dispose = n, this._maxPerKey = r;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	acquire(e) {
+		let t = this._pools.get(e);
+		if (t && t.length > 0) {
+			let e = t.pop();
+			return this._reset?.(e), e;
+		}
+		return this._factory(e);
+	}
+	release(e, t) {
+		let n = this._pools.get(e);
+		if (n || (n = [], this._pools.set(e, n)), n.length >= this._maxPerKey) {
+			this._dispose?.(t);
+			return;
+		}
+		n.push(t);
+	}
+	size(e) {
+		return this._pools.get(e)?.length ?? 0;
+	}
+	get totalSize() {
+		let e = 0;
+		for (let t of this._pools.values()) e += t.length;
+		return e;
+	}
+	clear() {
+		if (this._dispose) for (let e of this._pools.values()) for (let t of e) this._dispose(t);
+		this._pools.clear();
+	}
+	destroy() {
+		this._isDestroyed ||= (this.clear(), !0);
+	}
+}, O = class {
+	_pool;
+	constructor(e, t = 20) {
+		this._registry = e, this._pool = new D((e) => this._registry.create(e), (e) => e.reset(), (e) => e.destroy(), t);
+	}
+	acquire(e) {
+		let t = this._pool.acquire(e);
+		return t.symbolId !== e && t.activate(e), t;
+	}
+	release(e) {
+		let t = e.symbolId;
+		e.deactivate(), this._pool.release(t, e);
+	}
+	destroy() {
+		this._pool.destroy();
+	}
+}, k = class {
+	_symbols;
+	_weights;
+	_cumulativeWeights = [];
+	_totalWeight = 0;
+	_excludeSpinning = /* @__PURE__ */ new Set();
+	_excludeBuffer = /* @__PURE__ */ new Set();
+	constructor(e) {
+		this._symbols = Object.keys(e), this._weights = this._symbols.map((t) => e[t].weight), this._rebuildWeights();
+	}
+	next(e = !1) {
+		let t = e ? new Set([...this._excludeSpinning, ...this._excludeBuffer]) : this._excludeSpinning;
+		if (t.size === 0) return this._pickWeighted();
+		let n = 0, r = [];
+		for (let e = 0; e < this._symbols.length; e++) t.has(this._symbols[e]) || (n += this._weights[e], r.push({
+			id: this._symbols[e],
+			cumWeight: n
+		}));
+		if (n === 0 || r.length === 0) {
+			for (let e of this._symbols) if (!t.has(e)) return e;
+			return this._symbols[0];
+		}
+		let i = Math.random() * n, a = 0, o = r.length - 1;
+		for (; a < o;) {
+			let e = a + o >> 1;
+			r[e].cumWeight <= i ? a = e + 1 : o = e;
+		}
+		return r[a].id;
+	}
+	setExcludeSpinning(e) {
+		this._excludeSpinning = new Set(e);
+	}
+	setExcludeBuffer(e) {
+		this._excludeBuffer = new Set(e);
+	}
+	updateWeights(e) {
+		this._symbols = Object.keys(e), this._weights = this._symbols.map((t) => e[t].weight), this._rebuildWeights();
+	}
+	_rebuildWeights() {
+		this._cumulativeWeights = [], this._totalWeight = 0;
+		for (let e of this._weights) this._totalWeight += e, this._cumulativeWeights.push(this._totalWeight);
+	}
+	_pickWeighted() {
+		let e = Math.random() * this._totalWeight, t = 0, n = this._cumulativeWeights.length - 1;
+		for (; t < n;) {
+			let r = t + n >> 1;
+			this._cumulativeWeights[r] <= e ? t = r + 1 : n = r;
+		}
+		return this._symbols[t];
+	}
+}, A = class {
+	_middlewares = [];
+	_sorted = !1;
+	constructor(e) {
+		this._randomProvider = e, this.use(new j(e)), this.use(new M());
+	}
+	use(e) {
+		return this._middlewares.push(e), this._sorted = !1, this;
+	}
+	remove(e) {
+		return this._middlewares = this._middlewares.filter((t) => t.name !== e), this;
+	}
+	build(e, t, n, r, i, a = !1) {
+		this._sorted ||= (this._middlewares.sort((e, t) => e.priority - t.priority), !0);
+		let o = n + t + r, s = {
+			reelIndex: e,
+			visibleRows: t,
+			bufferAbove: n,
+			bufferBelow: r,
+			symbols: Array(o).fill(""),
+			targetSymbols: i,
+			isSpinning: a,
+			metadata: {}
+		}, c = 0, l = () => {
+			c < this._middlewares.length && this._middlewares[c++].process(s, l);
+		};
+		return l(), s.symbols;
+	}
+	buildAll(e, t, n, r, i, a = !1) {
+		return Array.from({ length: e }, (e, o) => this.build(o, t, n, r, i?.[o], a));
+	}
+	get randomProvider() {
+		return this._randomProvider;
+	}
+}, j = class {
+	name = "random-fill";
+	priority = 0;
+	constructor(e) {
+		this._provider = e;
+	}
+	process(e, t) {
+		for (let t = 0; t < e.symbols.length; t++) if (!e.symbols[t]) {
+			let n = t < e.bufferAbove || t >= e.bufferAbove + e.visibleRows;
+			e.symbols[t] = this._provider.next(n);
+		}
+		t();
+	}
+}, M = class {
+	name = "target-placement";
+	priority = 10;
+	process(e, t) {
+		if (e.targetSymbols) for (let t = 0; t < e.targetSymbols.length; t++) {
+			let n = e.bufferAbove + t;
+			n < e.symbols.length && (e.symbols[n] = e.targetSymbols[t]);
+		}
+		t();
+	}
+}, N = class {
+	_offsets = [];
+	constructor(e, t, n, r) {
+		this._reelCount = e, this._totalRows = t, this._symbolWidth = n, this._config = r, this._compute();
+	}
+	getOffset(e, t) {
+		return this._offsets[e]?.[t] ?? 0;
+	}
+	get offsets() {
+		return this._offsets;
+	}
+	_compute() {
+		if (this._config.mode === "none") {
+			this._offsets = Array.from({ length: this._reelCount }, () => Array(this._totalRows).fill(0));
+			return;
+		}
+		let e = this._config, t = (this._reelCount - 1) / 2;
+		this._offsets = [];
+		for (let n = 0; n < this._reelCount; n++) {
+			let r = this._reelCount > 1 ? (n - t) / (this._reelCount / 2) : 0, i = [];
+			for (let t = 0; t < this._totalRows; t++) {
+				let n = this._totalRows > 1 ? t / (this._totalRows - 1) : .5, a = r * e.widthDifference * e.topWidthFactor, o = a + (r * e.widthDifference * e.bottomWidthFactor - a) * n;
+				i.push(o);
+			}
+			this._offsets.push(i);
+		}
+	}
+}, P = class {
+	_reelCount;
+	_visibleRows;
+	_symbolWidth;
+	_symbolHeight;
+	_symbolGap = { ...w.symbolGap };
+	_bufferSymbols = w.bufferSymbols;
+	_symbolRegistry = new E();
+	_weights = {};
+	_speeds = /* @__PURE__ */ new Map();
+	_initialSpeed = w.initialSpeed;
+	_offset = { mode: "none" };
+	_ticker;
+	_spinningMode = new u();
+	_phaseFactory = new v();
+	_middlewares = [];
+	_initialFrame;
+	_symbolDataOverrides = {};
+	reels(e) {
+		return this._reelCount = e, this;
+	}
+	visibleSymbols(e) {
+		return this._visibleRows = e, this;
+	}
+	symbolSize(e, t) {
+		return this._symbolWidth = e, this._symbolHeight = t, this;
+	}
+	symbolGap(e, t) {
+		return this._symbolGap = {
+			x: e,
+			y: t
+		}, this;
+	}
+	bufferSymbols(e) {
+		return this._bufferSymbols = e, this;
+	}
+	symbols(e) {
+		return e(this._symbolRegistry), this;
+	}
+	weights(e) {
+		return this._weights = e, this;
+	}
+	symbolData(e) {
+		return this._symbolDataOverrides = {
+			...this._symbolDataOverrides,
+			...e
+		}, this;
+	}
+	speed(e, t) {
+		return this._speeds.set(e, t), this;
+	}
+	initialSpeed(e) {
+		return this._initialSpeed = e, this;
+	}
+	offsetConfig(e) {
+		return this._offset = e, this;
+	}
+	ticker(e) {
+		return this._ticker = e, this;
+	}
+	spinningMode(e) {
+		return this._spinningMode = e, this;
+	}
+	frameMiddleware(e) {
+		return this._middlewares.push(e), this;
+	}
+	phases(e) {
+		return e(this._phaseFactory), this;
+	}
+	initialFrame(e) {
+		return this._initialFrame = e, this;
+	}
+	build() {
+		this._validate();
+		let e = this._reelCount, t = this._visibleRows, n = this._symbolWidth, r = this._symbolHeight, i = this._bufferSymbols, a = this._bufferSymbols, o = this._ticker;
+		this._speeds.size === 0 && this._speeds.set("normal", T.NORMAL);
+		let s = {}, c = this._symbolRegistry.symbolIds;
+		for (let e of c) {
+			let t = this._symbolDataOverrides[e] ?? {};
+			s[e] = {
+				weight: t.weight ?? this._weights[e] ?? 10,
+				zIndex: t.zIndex ?? 1,
+				unmask: t.unmask
+			};
+		}
+		let l = {
+			grid: {
+				reelCount: e,
+				visibleRows: t,
+				symbolWidth: n,
+				symbolHeight: r,
+				symbolGap: { ...this._symbolGap },
+				bufferSymbols: this._bufferSymbols
+			},
+			symbols: s,
+			speeds: this._speeds,
+			initialSpeed: this._initialSpeed,
+			offset: this._offset,
+			ticker: o
+		}, u = new O(this._symbolRegistry), p = new k(s), m = new A(p);
+		for (let e of this._middlewares) m.use(e);
+		let h = new f(e * (n + this._symbolGap.x) - this._symbolGap.x, t * (r + this._symbolGap.y) - this._symbolGap.y);
+		new N(e, i + t + a, n, this._offset);
+		let g = this._initialFrame ? m.buildAll(e, t, i, a, this._initialFrame) : m.buildAll(e, t, i, a), _ = [];
+		for (let o = 0; o < e; o++) {
+			let e = new d({
+				reelIndex: o,
+				visibleRows: t,
+				bufferAbove: i,
+				bufferBelow: a,
+				symbolWidth: n,
+				symbolHeight: r,
+				symbolGapX: this._symbolGap.x,
+				symbolGapY: this._symbolGap.y,
+				symbolsData: s,
+				initialSymbols: g[o]
+			}, u, p, h);
+			_.push(e);
+		}
+		return new C({
+			config: l,
+			reels: _,
+			viewport: h,
+			symbolFactory: u,
+			frameBuilder: m,
+			phaseFactory: this._phaseFactory,
+			spinningMode: this._spinningMode
+		});
+	}
+	_validate() {
+		let e = [];
+		if ((this._reelCount === void 0 || this._reelCount <= 0) && e.push("reels() must be called with a positive number."), (this._visibleRows === void 0 || this._visibleRows <= 0) && e.push("visibleSymbols() must be called with a positive number."), (this._symbolWidth === void 0 || this._symbolHeight === void 0) && e.push("symbolSize() must be called with width and height."), this._symbolRegistry.size === 0 && e.push("symbols() must register at least one symbol."), this._ticker || e.push("ticker() must be called with a PixiJS Ticker."), this._speeds.size > 0 && !this._speeds.has(this._initialSpeed) && e.push(`initialSpeed '${this._initialSpeed}' does not match any registered speed profile. Available: ${[...this._speeds.keys()].join(", ")}`), e.length > 0) throw Error(`ReelSetBuilder validation failed:\n  - ${e.join("\n  - ")}`);
+	}
+}, F = class extends e {
+	_sprite;
+	_textures;
+	_winTween = null;
+	constructor(e) {
+		super(), this._textures = e.textures;
+		let t = e.anchor ?? {
+			x: 0,
+			y: 0
+		};
+		this._sprite = new a(), this._sprite.anchor.set(t.x, t.y), this.view.addChild(this._sprite);
+	}
+	onActivate(e) {
+		let t = this._textures[e];
+		t && (this._sprite.texture = t);
+	}
+	onDeactivate() {
+		this._killWinTween(), this._sprite.scale.set(1, 1);
+	}
+	async playWin() {
+		return this._killWinTween(), new Promise((e) => {
+			this._winTween = o.to(this._sprite.scale, {
+				x: 1.15,
+				y: 1.15,
+				duration: .15,
+				yoyo: !0,
+				repeat: 1,
+				ease: "power2.inOut",
+				onComplete: e
+			});
+		});
+	}
+	stopAnimation() {
+		this._killWinTween(), this._sprite.scale.set(1, 1);
+	}
+	resize(e, t) {
+		this._sprite.width = e, this._sprite.height = t;
+	}
+	onDestroy() {
+		this._killWinTween();
+	}
+	_killWinTween() {
+		this._winTween &&= (this._winTween.kill(), null);
+	}
+}, I = class extends e {
+	_animSprite;
+	_frames;
+	_animationSpeed;
+	_winResolve = null;
+	constructor(e) {
+		super(), this._frames = e.frames, this._animationSpeed = e.animationSpeed ?? 1;
+		let t = e.anchor ?? {
+			x: 0,
+			y: 0
+		}, r = Object.values(this._frames)[0] ?? [];
+		this._animSprite = new n(r.length > 0 ? r : []), this._animSprite.anchor.set(t.x, t.y), this._animSprite.animationSpeed = this._animationSpeed, this._animSprite.loop = !1, this.view.addChild(this._animSprite);
+	}
+	onActivate(e) {
+		let t = this._frames[e];
+		t && t.length > 0 && (this._animSprite.textures = t, this._animSprite.gotoAndStop(0));
+	}
+	onDeactivate() {
+		this._animSprite.stop(), this._winResolve = null;
+	}
+	async playWin() {
+		return new Promise((e) => {
+			this._winResolve = e, this._animSprite.loop = !1, this._animSprite.onComplete = () => {
+				this._winResolve = null, this._animSprite.onComplete = void 0, e();
+			}, this._animSprite.gotoAndPlay(0);
+		});
+	}
+	stopAnimation() {
+		this._animSprite.stop(), this._animSprite.gotoAndStop(0), this._winResolve &&= (this._winResolve(), null);
+	}
+	resize(e, t) {
+		this._animSprite.width = e, this._animSprite.height = t;
+	}
+}, L = class {
+	name = "cascade";
+	_gravity;
+	constructor(e = 1.5) {
+		this._gravity = e;
+	}
+	computeDeltaY(e, t, n) {
+		let r = e * t * this._gravity * n / 1e3;
+		return Math.min(r, e);
+	}
+}, R = class {
+	name = "immediate";
+	computeDeltaY(e, t, n) {
+		return 0;
+	}
+};
+//#endregion
+//#region src/debug/debug.ts
+function z(e) {
+	let t = e.reels, n = t.map((e, t) => ({
+		index: t,
+		speed: e.speed,
+		isStopping: e.isStopping,
+		allSymbols: e.symbols.map((e, t) => ({
+			row: t,
+			symbolId: e.symbolId,
+			y: Math.round(e.view.y)
+		})),
+		visibleSymbols: e.getVisibleSymbols()
+	})), r = [];
+	for (let e of n) r.push(e.visibleSymbols);
+	return {
+		timestamp: Date.now(),
+		isSpinning: e.isSpinning,
+		currentSpeed: e.speed.activeName,
+		availableSpeeds: e.speed.profileNames,
+		spotlightActive: e.spotlight.isActive,
+		reelCount: t.length,
+		visibleRows: t[0]?.getVisibleSymbols().length ?? 0,
+		reels: n,
+		grid: r
+	};
+}
+function B(e) {
+	let { grid: t, visibleRows: n } = z(e);
+	if (t.length === 0) return "(empty grid)";
+	let r = (e) => e.slice(0, 8).padEnd(8), i = (e, n, r) => e + t.map(() => "─".repeat(8)).join(n) + r, a = [];
+	a.push(i("┌", "┬", "┐"));
+	for (let e = 0; e < n; e++) {
+		let n = t.map((t) => r(t[e] ?? "?"));
+		a.push("│" + n.join("│") + "│");
+	}
+	return a.push(i("└", "┴", "┘")), a.join("\n");
+}
+function V(e) {
+	typeof window > "u" || (window.__PIXI_REELS_DEBUG = {
+		reelSet: e,
+		snapshot: () => z(e),
+		grid: () => B(e),
+		log: () => {
+			let t = z(e);
+			return console.log(`[pixi-reels debug] spinning=${t.isSpinning} speed=${t.currentSpeed}`), console.log(B(e)), t;
+		},
+		trace: () => {
+			for (let t of [
+				"spin:start",
+				"spin:allStarted",
+				"spin:stopping",
+				"spin:reelLanded",
+				"spin:allLanded",
+				"spin:complete",
+				"skip:requested",
+				"skip:completed",
+				"speed:changed",
+				"spotlight:start",
+				"spotlight:end",
+				"destroyed"
+			]) e.events.on(t, (...e) => {
+				console.log(`[pixi-reels] ${t}`, ...e);
+			});
+			console.log("[pixi-reels debug] tracing enabled for all events");
+		}
+	}, console.log("[pixi-reels] Debug mode enabled. Use __PIXI_REELS_DEBUG.log() to inspect state."));
+}
+//#endregion
+//#region src/testing/FakeTicker.ts
+var H = class {
+	deltaMS = 16;
+	deltaTime = 1;
+	elapsedMS = 0;
+	lastTime = 0;
+	speed = 1;
+	started = !1;
+	FPS = 60;
+	minFPS = 10;
+	maxFPS = 0;
+	_callbacks = [];
+	add(e) {
+		return this._callbacks.push(e), this;
+	}
+	addOnce(e) {
+		let t = (n) => {
+			this.remove(t), e(n);
+		};
+		return this.add(t);
+	}
+	remove(e) {
+		let t = this._callbacks.indexOf(e);
+		return t !== -1 && this._callbacks.splice(t, 1), this;
+	}
+	start() {
+		return this.started = !0, this;
+	}
+	stop() {
+		return this.started = !1, this;
+	}
+	destroy() {
+		this._callbacks.length = 0, this.started = !1;
+	}
+	tick(e = 16) {
+		this.deltaMS = e, this.deltaTime = e / (1e3 / 60), this.elapsedMS += e, this.lastTime += e;
+		let t = this._callbacks.slice();
+		for (let e of t) e(this);
+	}
+	tickFor(e, t = 16) {
+		let n = e;
+		for (; n > 0;) {
+			let e = Math.min(t, n);
+			this.tick(e), n -= e;
+		}
+	}
+	get listenerCount() {
+		return this._callbacks.length;
+	}
+}, U = class extends e {
+	_width = 0;
+	_height = 0;
+	onActivate(e) {}
+	onDeactivate() {}
+	async playWin() {}
+	stopAnimation() {}
+	resize(e, t) {
+		this._width = e, this._height = t;
+	}
+	get width() {
+		return this._width;
+	}
+	get height() {
+		return this._height;
+	}
+};
+//#endregion
+//#region src/testing/testHarness.ts
+function W(e = {}) {
+	let t = e.reels ?? 5, n = e.visibleRows ?? 3, r = e.symbolIds ?? [
+		"a",
+		"b",
+		"c"
+	], i = e.weights ?? {}, a = e.symbolSize ?? {
+		width: 100,
+		height: 100
+	}, o = new H(), s = new P().reels(t).visibleSymbols(n).symbolSize(a.width, a.height).ticker(o).symbols((e) => {
+		for (let t of r) e.register(t, U, {});
+	});
+	Object.keys(i).length > 0 && s.weights(i);
+	let c = s.build();
+	return {
+		reelSet: c,
+		ticker: o,
+		advance(e, t = 16) {
+			o.tickFor(e, t);
+		},
+		async spinAndLand(e) {
+			return G(c, e);
+		},
+		destroy() {
+			c.destroy(), o.destroy();
+		}
+	};
+}
+async function G(e, t) {
+	let n = e.spin();
+	return e.setResult(t), e.skip(), n;
+}
+function K(e, t) {
+	let n = [];
+	for (let r of t) e.events.on(r, (...e) => {
+		n.push({
+			event: r,
+			args: e
+		});
+	});
+	return n;
+}
+function q(e, t) {
+	let n = z(e).grid, r = [];
+	if (n.length !== t.length) throw Error(`Grid reel count mismatch: expected ${t.length} got ${n.length}\n${B(e)}`);
+	for (let e = 0; e < t.length; e++) for (let i = 0; i < t[e].length; i++) t[e][i] !== n[e][i] && r.push(`  reel ${e} row ${i}: expected "${t[e][i]}" got "${n[e][i]}"`);
+	if (r.length > 0) throw Error(`Grid mismatch:\n${r.join("\n")}\n\nCurrent grid:\n${B(e)}`);
+}
+function J(e, t) {
+	let n = 0;
+	for (let r of z(e).grid) for (let e of r) e === t && n++;
+	return n;
+}
+//#endregion
+export { I as AnimatedSpriteSymbol, _ as AnticipationPhase, L as CascadeMode, w as DEFAULTS, s as EventEmitter, H as FakeTicker, A as FrameBuilder, U as HeadlessSymbol, R as ImmediateMode, D as ObjectPool, N as OffsetCalculator, v as PhaseFactory, k as RandomSymbolProvider, d as Reel, c as ReelMotion, p as ReelPhase, C as ReelSet, P as ReelSetBuilder, e as ReelSymbol, f as ReelViewport, x as SpeedManager, T as SpeedPresets, b as SpinController, h as SpinPhase, t as SpineSymbol, F as SpriteSymbol, u as StandardMode, m as StartPhase, g as StopPhase, l as StopSequencer, O as SymbolFactory, E as SymbolRegistry, S as SymbolSpotlight, y as TickerRef, K as captureEvents, J as countSymbol, W as createTestReelSet, B as debugGrid, z as debugSnapshot, V as enableDebug, q as expectGrid, G as spinAndLand };
+
+//# sourceMappingURL=index.js.map