@adiakys/feeling-lucky 0.0.0-stage → 0.2.0

package/dist/panel-tWJMt9kl.js

@@ -0,0 +1,545 @@
+import { A as e, B as t, C as n, D as r, E as i, F as a, I as o, L as s, M as c, N as l, O as u, P as d, R as f, S as p, T as m, _ as h, a as ee, b as te, c as ne, d as g, f as _, g as v, h as y, i as b, j as x, k as S, l as C, m as re, n as ie, o as w, p as ae, r as oe, s as T, u as se, v as E, w as ce, x as D, y as O, z as k } from "./mount-CBUkAcVV.js";
+// node_modules/lit-html/directives/live.js
+var A = x(class extends c {
+	constructor(t) {
+		if (super(t), t.type !== l.PROPERTY && t.type !== l.ATTRIBUTE && t.type !== l.BOOLEAN_ATTRIBUTE) throw Error("The `live` directive is not allowed on child or event bindings");
+		if (!e(t)) throw Error("`live` bindings can only contain a single expression");
+	}
+	render(e) {
+		return e;
+	}
+	update(e, [t]) {
+		if (t === k || t === f) return t;
+		let n = e.element, r = e.name;
+		if (e.type === l.PROPERTY) {
+			if (t === n[r]) return k;
+		} else if (e.type === l.BOOLEAN_ATTRIBUTE) {
+			if (!!t === n.hasAttribute(r)) return k;
+		} else if (e.type === l.ATTRIBUTE && n.getAttribute(r) === t + "") return k;
+		return S(e), t;
+	}
+}), j = [
+	["path", { d: "m18 16 4-4-4-4" }],
+	["path", { d: "m6 8-4 4 4 4" }],
+	["path", { d: "m14.5 4-5 16" }]
+], M = [
+	["circle", {
+		cx: "9",
+		cy: "12",
+		r: "1"
+	}],
+	["circle", {
+		cx: "9",
+		cy: "5",
+		r: "1"
+	}],
+	["circle", {
+		cx: "9",
+		cy: "19",
+		r: "1"
+	}],
+	["circle", {
+		cx: "15",
+		cy: "12",
+		r: "1"
+	}],
+	["circle", {
+		cx: "15",
+		cy: "5",
+		r: "1"
+	}],
+	["circle", {
+		cx: "15",
+		cy: "19",
+		r: "1"
+	}]
+], N = [["rect", {
+	width: "18",
+	height: "11",
+	x: "3",
+	y: "11",
+	rx: "2",
+	ry: "2"
+}], ["path", { d: "M7 11V7a5 5 0 0 1 9.9-1" }]], P = [["path", { d: "M5 12h14" }]], F = [
+	"automatic",
+	"loss",
+	"win",
+	"jackpot"
+], I = {
+	wheel: [
+		"segment",
+		"booster",
+		"prize"
+	],
+	slot: ["combination", "prize"],
+	roulette: ["number", "storm"],
+	pachinko: ["pocket", "violet"],
+	scratch: ["award", "prize"],
+	blackjack: ["prize"],
+	holdem: ["prize"]
+}, L = [
+	"segment",
+	"combination",
+	"number",
+	"pocket",
+	"award"
+], R = {}, z = { prizes: [] }, B = () => ({
+	multiplier: void 0,
+	variant: void 0,
+	result: "automatic",
+	advanced: {}
+}), V = {
+	slot: ae,
+	scratch: re
+}, H = (e) => R[e] ?? B();
+function U(e) {
+	let t = e.indexOf(":");
+	return {
+		tier: e.slice(0, t),
+		award: e.slice(t + 1) || null
+	};
+}
+var W = {
+	none: "none",
+	pair: "small",
+	logos: "big",
+	sevens: "big",
+	infinities: "jackpot"
+};
+async function le(e, t) {
+	let n = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(e));
+	return [...new Uint8Array(n)].map((e) => e.toString(16).padStart(2, "0")).join("") === t.toLowerCase();
+}
+// src/developer/rig.ts
+var G = {
+	automatic: void 0,
+	loss: "none",
+	win: "small",
+	jackpot: "jackpot"
+}, ue = g.indexOf("jackpot");
+function de(e, t) {
+	let { result: n, advanced: r } = H(e);
+	if (e === "wheel" && r.segment) {
+		let e = r.segment.split(":")[0];
+		return e === "coin" || e === "hunt" || e === "pachinko" ? t() === "big" ? "big" : "small" : e;
+	}
+	return e === "slot" && r.combination ? W[r.combination] : e === "pachinko" && r.pocket ? g[Number(r.pocket) - 1] : e === "scratch" && r.award ? U(r.award).tier : G[n] ?? t();
+}
+var K = () => H("pachinko").result === "jackpot" && !H("pachinko").advanced.pocket;
+function q(e, t) {
+	let r = Math.min(...e.map((e) => e.x)) + 16, i = Math.max(...e.map((e) => e.x)) - 16, a = (r + i) / 2;
+	return [...new Set(e.map((e) => e.y))].sort((e, t) => e - t).slice(1, 1 + t).flatMap((t) => {
+		let o = Math.max(r, Math.min(i, a + n(-25, 25))), s = e.filter((e) => e.y === t).sort((e, t) => Math.abs(e.x - o) - Math.abs(t.x - o))[0];
+		return s ? (a = s.x, [s]) : [];
+	});
+}
+var J = {
+	boost: ({ game: e }, t) => H(e).multiplier ?? t(),
+	tier: ({ game: e }, t) => de(e, t),
+	prize: ({ game: e, prizeIds: t }, n) => {
+		let { prize: r, award: i } = H(e).advanced;
+		if (r && t.includes(r)) return r;
+		if (e !== "scratch" || !i) return n();
+		let { tier: a, award: o } = U(i), s = D(z.prizes.filter(({ id: e }) => t.includes(e)), a, o);
+		return s.length ? p(s).id : n();
+	},
+	"wheel.segment": ({ segments: e }, t) => {
+		let n = H("wheel").advanced.segment, r = n ? e.flatMap((e, t) => ne(e) === n ? [t] : []) : [];
+		return r.length ? p(r) : t();
+	},
+	"wheel.booster": ({ segments: e }, t) => {
+		let n = H("wheel").advanced.booster;
+		return n && T(e).includes(n) ? n : t();
+	},
+	"slot.line": ({ prizeId: e }, t) => {
+		let { combination: n } = H("slot").advanced, r = n === "logos" ? e : n === "sevens" ? "seven" : void 0;
+		return r ? [
+			r,
+			r,
+			r
+		] : t();
+	},
+	"roulette.number": ({ bets: e, storm: t, boost: n }, r) => {
+		let { result: i, advanced: a } = H("roulette");
+		if (a.number) return Number(a.number);
+		let o = G[i];
+		if (!o && !a.storm) return r();
+		let s = ie.filter((n) => {
+			let r = oe(e, n)?.tier ?? "none";
+			return (!o || (o === "small" ? r !== "none" : r === o)) && (!a.storm || t.includes(n) === (a.storm === "hit"));
+		});
+		return s.length ? p(s.flatMap((e) => Array(t.includes(e) ? n : 1).fill(e))) : r();
+	},
+	"pachinko.board": ({ pegs: e }, t) => {
+		let n = t();
+		if (!K()) return n;
+		let [r, i] = _, a = (e) => e.y >= r && e.y <= i;
+		if (H("pachinko").advanced.violet === "hit") {
+			let t = q(e, 9), n = p(t.filter(a));
+			return {
+				violet: n,
+				reds: t.filter((e) => e !== n)
+			};
+		}
+		let o = q(e, 8), s = e.filter((e) => !o.includes(e) && a(e));
+		return {
+			violet: s.includes(n.violet) ? n.violet : p(s),
+			reds: o
+		};
+	},
+	"pachinko.route": ({ violet: e, reds: t }, n) => {
+		let { violet: r } = H("pachinko").advanced;
+		return !K() && !r ? n() : {
+			through: [...K() ? t : [], ...r === "hit" ? [e] : []].sort((e, t) => e.y - t.y),
+			avoid: r === "miss" ? [e] : []
+		};
+	},
+	"pachinko.wins": (e, t) => {
+		let n = G[H("pachinko").result];
+		return n ? n !== "none" : t();
+	},
+	"pachinko.pocket": (e, t) => {
+		let { pocket: n } = H("pachinko").advanced;
+		return n ? Number(n) - 1 : K() ? ue : t();
+	},
+	"scratch.ticket": (e, t) => H("scratch").variant ?? t(),
+	locale: (e, t) => z.locale ?? t(),
+	dealer: ({ count: e }, t) => z.dealer === void 0 ? t() : z.dealer === "none" ? null : z.dealer < e ? z.dealer : t(),
+	theme: (e, t) => z.theme === void 0 ? t() : z.theme === "none" ? null : z.theme,
+	"slot.machine": (e, t) => H("slot").variant ?? t(),
+	"breakaway.tackle": (e, t) => G[H("slot").result] && G[H("slot").result] !== "none" ? null : t(),
+	"scratch.award": (e, t) => {
+		let { award: n } = H("scratch").advanced;
+		return n ? U(n).award : t();
+	}
+}, Y = "feeling-lucky.developer", X = 8, Z = [
+	"small",
+	"big",
+	"coin",
+	"hunt",
+	"pachinko",
+	"jackpot"
+], Q = !1, $ = class extends ee {
+	constructor() {
+		super(), this.open = !0, this.unlocked = Q, this.password = "", this.wrong = !1, this.minimized = !1, this.position = {
+			x: innerWidth - 416 - 16,
+			y: 108
+		}, this.selected = "wheel", this.draft = B(), this.loads = 0, this.advancedOpen = !1, this.drag = null, this.dragged = !1, this.lastFocus = null, this.grab = (e) => {
+			if (e.button !== 0 || !this.minimized && e.target.closest("button")) return;
+			let t = this.box.getBoundingClientRect();
+			this.drag = {
+				offsetX: e.clientX - t.left,
+				offsetY: e.clientY - t.top,
+				startX: e.clientX,
+				startY: e.clientY
+			}, this.dragged = !1, e.currentTarget.setPointerCapture(e.pointerId);
+		}, this.move = (e) => {
+			this.drag && (!this.dragged && Math.hypot(e.clientX - this.drag.startX, e.clientY - this.drag.startY) < 4 || (this.dragged = !0, this.place(e.clientX - this.drag.offsetX, e.clientY - this.drag.offsetY)));
+		}, this.release = () => {
+			this.drag && this.dragged && this.save(), this.drag = null;
+		}, this.restore = () => {
+			this.dragged ? this.dragged = !1 : this.minimize(!1);
+		}, this.unlock = async (e) => {
+			e.preventDefault();
+			let t = this.password;
+			this.password = "", this.wrong = !await le(t, this.passwordHash ?? ""), !this.wrong && (this.grant(), this.focusFirst());
+		}, this.apply = () => {
+			let e = Object.fromEntries(Object.entries(this.draft.advanced).filter(([, e]) => e !== void 0));
+			this.draft.multiplier !== void 0 || this.draft.variant !== void 0 || this.draft.result !== "automatic" || Object.keys(e).length ? R[this.selected] = {
+				...this.draft,
+				advanced: e
+			} : delete R[this.selected], h(this.selected);
+		}, this.reset = () => {
+			for (let e of y) delete R[e];
+			this.load(this.selected), h(this.selected);
+		}, this.toggle = () => {
+			this.open = !this.open, this.open ? (this.lastFocus = this.activeElement, this.focusFirst()) : this.lastFocus instanceof HTMLElement && this.lastFocus.isConnected && this.lastFocus.focus();
+		}, this.shortcut = (e) => {
+			e.ctrlKey && e.shiftKey && e.code === "KeyL" && (e.preventDefault(), e.stopPropagation(), e.repeat || this.toggle());
+		}, this.keydown = (e) => {
+			e.stopPropagation(), e.key === "Escape" && this.toggle();
+		}, this.fit = () => this.place(this.position.x, this.position.y), this.segmentOption = (e) => {
+			if (e === "none") return {
+				value: e,
+				label: this.t("developer.option.nothing")
+			};
+			if (e === "jackpot") return {
+				value: e,
+				label: this.t("developer.jackpot")
+			};
+			if (e === "coin" || e === "hunt" || e === "pachinko") return {
+				value: e,
+				label: this.t(`wheel.segment.${e}`)
+			};
+			let { tier: t, award: n } = U(e);
+			return {
+				value: e,
+				label: this.awardLabel(t, n)
+			};
+		}, this.selectGame = (e) => {
+			this.selected = e.target.value, this.load(this.selected);
+		};
+		try {
+			let e = JSON.parse(localStorage.getItem(Y) ?? "null");
+			e && (this.position = {
+				x: e.x,
+				y: e.y
+			}, this.minimized = e.minimized);
+		} catch {}
+		this.load(this.selected);
+	}
+	willUpdate() {
+		z.prizes = this.room.prizes, !this.unlocked && this.passwordHash === void 0 && this.grant();
+	}
+	get activeElement() {
+		return this.getRootNode().activeElement;
+	}
+	load(e) {
+		this.draft = structuredClone(H(e)), this.loads++;
+	}
+	save() {
+		try {
+			localStorage.setItem(Y, JSON.stringify({
+				...this.position,
+				minimized: this.minimized
+			}));
+		} catch {}
+	}
+	place(e, t) {
+		let n = this.box?.offsetWidth ?? 0, r = this.box?.offsetHeight ?? 0;
+		this.position = {
+			x: Math.max(X, Math.min(innerWidth - n - X, e)),
+			y: Math.max(X, Math.min(innerHeight - r - X, t))
+		};
+	}
+	async focusFirst() {
+		await this.updateComplete, this.place(this.position.x, this.position.y), (this.minimized && this.unlocked ? this.iconButton : this.first)?.focus();
+	}
+	minimize(e) {
+		this.minimized = e, this.save(), this.focusFirst();
+	}
+	grant() {
+		v(J), this.unlocked = Q = !0;
+	}
+	setLanguage(e) {
+		z.locale = e || void 0, E.value++;
+	}
+	setDealer(e) {
+		z.dealer = e === "" ? void 0 : e === "none" ? "none" : Number(e), E.value++, this.requestUpdate();
+	}
+	setTheme(e) {
+		z.theme = e || void 0, E.value++, this.requestUpdate();
+	}
+	connectedCallback() {
+		super.connectedCallback(), this.lastFocus = this.activeElement, addEventListener("keydown", this.shortcut, !0), addEventListener("resize", this.fit);
+	}
+	firstUpdated() {
+		this.focusFirst();
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback(), removeEventListener("keydown", this.shortcut, !0), removeEventListener("resize", this.fit);
+	}
+	awardLabel(e, t) {
+		return this.t("developer.option.award", {
+			tier: this.t(`tier.${e}`),
+			award: this.room.award(e, t)
+		});
+	}
+	options(e) {
+		let t = (e, t) => [{
+			value: "hit",
+			label: this.t(`developer.option.${e}`)
+		}, {
+			value: "miss",
+			label: this.t(`developer.option.${t}`)
+		}], n = () => T(C(this.room.board)).sort((e, t) => Z.indexOf(e.split(":")[0]) - Z.indexOf(t.split(":")[0]));
+		switch (e) {
+			case "segment": return ["none", ...n()].map(this.segmentOption);
+			case "booster": return n().map(this.segmentOption);
+			case "prize": return this.room.prizes.map((e) => ({
+				value: e.id,
+				label: e.name
+			}));
+			case "combination": return [
+				"none",
+				"pair",
+				"logos",
+				"sevens",
+				"infinities"
+			].map((e) => ({
+				value: e,
+				label: this.t(`developer.option.${e}`)
+			}));
+			case "number": return Array.from({ length: 37 }, (e, t) => ({
+				value: String(t),
+				label: String(t)
+			}));
+			case "storm": return t("lands", "misses");
+			case "violet": return t("hit", "miss");
+			case "pocket": return g.map((e, t) => ({
+				value: String(t + 1),
+				label: this.t("developer.option.pocket", { n: t + 1 })
+			}));
+			case "award": return O.flatMap((e) => this.room.board[e].map((t) => ({
+				value: te(e, t),
+				label: this.awardLabel(e, t)
+			})));
+		}
+	}
+	change(e, t) {
+		this.draft = {
+			...this.draft,
+			[e]: t
+		};
+	}
+	changeAdvanced(e, t) {
+		this.draft = {
+			...this.draft,
+			advanced: {
+				...this.draft.advanced,
+				[e]: t || void 0
+			}
+		};
+	}
+	choices(e, n, r) {
+		return t`<option value="" ?selected=${n === void 0}>${r}</option>
+      ${e.map((e) => t`<option value=${e.value} ?selected=${e.value === n}>${e.label}</option>`)}`;
+	}
+	renderBody() {
+		if (!this.unlocked) return t`<form class="lk-dev-body" @submit=${this.unlock}>
+        <label class="lk-dev-row">${this.t("developer.password")}
+          <input
+            data-first
+            type="password"
+            autocomplete="off"
+            .value=${A(this.password)}
+            aria-invalid=${this.wrong}
+            aria-describedby=${this.wrong ? "lk-dev-wrong" : f}
+            @input=${(e) => {
+			this.password = e.target.value, this.wrong = !1;
+		}}
+          />
+        </label>
+        ${this.wrong ? t`<p id="lk-dev-wrong" class="lk-dev-error" role="alert">${this.t("developer.wrongPassword")}</p>` : f}
+        <footer>
+          <button type="submit" class="is-primary" ?disabled=${!this.password}>${b(N)}${this.t("developer.unlock")}</button>
+        </footer>
+      </form>`;
+		let { selected: e, draft: n } = this, a = I[e].find((e) => L.includes(e) && n.advanced[e] !== void 0), o = V[e], s = (e) => e.target.value;
+		return t`<div class="lk-dev-body">
+      <p class="lk-dev-hint">${this.t("developer.hint")}</p>
+      <label class="lk-dev-row">${this.t("developer.theme")}
+        <select data-first @change=${(e) => this.setTheme(s(e))}>
+          ${this.choices([{
+			value: "none",
+			label: this.t("developer.noTheme")
+		}, ...se.map((e) => ({
+			value: e,
+			label: this.t(`themes.${e}.name`)
+		}))], z.theme, this.t("developer.calendar"))}
+        </select>
+      </label>
+      <label class="lk-dev-row">${this.t("developer.language")}
+        <select @change=${(e) => this.setLanguage(s(e))}>
+          ${this.choices(this.room.locales.map((e) => ({
+			value: e,
+			label: new Intl.DisplayNames([e], { type: "language" }).of(e) ?? e
+		})), z.locale, this.t("developer.autoLanguage"))}
+        </select>
+      </label>
+      ${this.room.dealers.length ? t`<label class="lk-dev-row">${this.t("developer.dealer")}
+            <select @change=${(e) => this.setDealer(s(e))}>
+              ${this.choices([{
+			value: "none",
+			label: this.t("developer.dealerAbsent")
+		}, ...this.room.dealers.map((e, t) => ({
+			value: String(t),
+			label: e.name ?? this.t("developer.dealerNumber", { n: t + 1 })
+		}))], z.dealer === void 0 ? void 0 : String(z.dealer), this.t("developer.dealerShifts"))}
+            </select>
+          </label>` : f}
+      <label class="lk-dev-row">${this.t("developer.game")}
+        <select @change=${this.selectGame}>
+          ${y.map((n) => t`<option value=${n} ?selected=${n === e}>${this.t(`games.${n}.name`)}</option>`)}
+        </select>
+      </label>
+      ${u(this.loads, t`<label class="lk-dev-row">${this.t("developer.multiplier")}
+        <select @change=${(e) => this.change("multiplier", Number(s(e)) || void 0)}>
+          ${this.choices([
+			1,
+			2,
+			3,
+			4,
+			5
+		].map((e) => ({
+			value: String(e),
+			label: `×${e}`
+		})), n.multiplier?.toString(), this.t("developer.daily"))}
+        </select>
+      </label>
+      ${o ? t`<label class="lk-dev-row">${this.t(`developer.variant.${e}`)}
+            <select @change=${(e) => this.change("variant", s(e) || void 0)}>
+              ${this.choices(o.map((t) => ({
+			value: t,
+			label: this.t(`${e}.names.${t}`)
+		})), n.variant, this.t("developer.daily"))}
+            </select>
+          </label>` : f}
+      <label class="lk-dev-row">${this.t("developer.result")}
+        <select ?disabled=${!!a} @change=${(e) => this.change("result", s(e))}>
+          ${F.map((e) => t`<option value=${e} ?selected=${e === n.result}>${this.t(`developer.${e}`)}</option>`)}
+        </select>
+      </label>
+      ${a ? t`<p class="lk-dev-note">${this.t("developer.decidedBy", { field: this.t(`developer.field.${a}`) })}</p>` : f}
+
+      <details
+        class="lk-dev-advanced"
+        ?open=${this.advancedOpen || I[e].some((e) => n.advanced[e] !== void 0)}
+        @toggle=${(e) => this.advancedOpen = e.target.open}
+      >
+        <summary>${b(i)}${this.t("developer.advanced")}</summary>
+        ${I[e].map((e) => t`<label class="lk-dev-row">${this.t(`developer.field.${e}`)}
+            <select @change=${(t) => this.changeAdvanced(e, s(t))}>
+              ${this.choices(this.options(e), n.advanced[e], this.t("developer.automatic"))}
+            </select>
+          </label>`)}
+        <p class="lk-dev-note">${this.t(`developer.about.${e}`)}</p>
+      </details>`)}
+
+      <footer>
+        <button type="button" @click=${this.reset}>${b(m)}${this.t("developer.reset")}</button>
+        <button type="button" class="is-primary" @click=${this.apply}>${b(r)}${this.t("developer.apply")}</button>
+      </footer>
+    </div>`;
+	}
+	render() {
+		if (!this.open) return f;
+		let e = this.unlocked && this.minimized;
+		return t`<div class="lk-dev ${e ? "is-icon" : ""}" style="left: ${this.position.x}px; top: ${this.position.y}px" @keydown=${this.keydown}>
+      ${e ? t`<button
+            type="button"
+            class="lk-dev-icon"
+            aria-label=${this.t("developer.restore")}
+            title=${this.t("developer.restore")}
+            @pointerdown=${this.grab}
+            @pointermove=${this.move}
+            @pointerup=${this.release}
+            @pointercancel=${this.release}
+            @click=${this.restore}
+          >
+            ${b(j)}
+          </button>` : t`<section class="lk-dev-panel" aria-label=${this.t("developer.title")}>
+            <header @pointerdown=${this.grab} @pointermove=${this.move} @pointerup=${this.release} @pointercancel=${this.release}>
+              ${b(M, "lk-dev-grip")}
+              <strong>${b(j)}${this.t("developer.title")}</strong>
+              ${this.unlocked ? t`<button type="button" aria-label=${this.t("developer.minimize")} title=${this.t("developer.minimize")} @click=${() => this.minimize(!0)}>
+                    ${b(P)}
+                  </button>` : f}
+              <button type="button" aria-label=${this.t("developer.close")} title=${this.t("developer.close")} @click=${this.toggle}>${b(ce)}</button>
+            </header>
+            ${this.renderBody()}
+          </section>`}
+    </div>`;
+	}
+};
+w([o({ attribute: !1 })], $.prototype, "passwordHash", void 0), w([a()], $.prototype, "open", void 0), w([a()], $.prototype, "unlocked", void 0), w([a()], $.prototype, "password", void 0), w([a()], $.prototype, "wrong", void 0), w([a()], $.prototype, "minimized", void 0), w([a()], $.prototype, "position", void 0), w([a()], $.prototype, "selected", void 0), w([a()], $.prototype, "draft", void 0), w([a()], $.prototype, "loads", void 0), w([a()], $.prototype, "advancedOpen", void 0), w([d(".lk-dev")], $.prototype, "box", void 0), w([d(".lk-dev [data-first]")], $.prototype, "first", void 0), w([d(".lk-dev-icon")], $.prototype, "iconButton", void 0), $ = w([s("fl-developer")], $);

package/dist/room/boost.d.ts

@@ -0,0 +1,2 @@
+import type { Translate } from '../runtime/i18n';
+export declare const boost: (t: Translate, multiplier: number, dealer?: boolean) => import("lit-html").TemplateResult<1>;

package/dist/room/certificate.d.ts

@@ -0,0 +1,22 @@
+import type { Win } from '../config/types';
+import type { Outcome } from '../engine/outcome';
+import { LuckyElement } from '../runtime/element';
+export declare class Certificate extends LuckyElement {
+    outcome: Outcome;
+    win: Win;
+    claim?: (win: Win) => Promise<void>;
+    private stage;
+    private gift;
+    private rising;
+    private claiming;
+    private claimed;
+    private error;
+    private seal?;
+    private lid?;
+    private get jackpot();
+    private stamp;
+    private unwrap;
+    private onClaim;
+    firstUpdated(): Promise<void>;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/room/chips.d.ts

@@ -0,0 +1,21 @@
+import { type PropertyValues } from 'lit';
+import { LuckyElement } from '../runtime/element';
+export declare class Chips extends LuckyElement {
+    chosen: string;
+    disabled: boolean;
+    locked: string | null;
+    count?: {
+        used: number;
+        max: number;
+    };
+    private edges;
+    private strip?;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private reveal;
+    private measure;
+    private wheel;
+    private choose;
+    private message;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/room/lobby.d.ts

@@ -0,0 +1,45 @@
+import { type PropertyValues } from 'lit';
+import '../games/roulette/wheel';
+import '../games/slot/machine';
+import '../games/wheel/face';
+import { LuckyElement } from '../runtime/element';
+export declare class Lobby extends LuckyElement {
+    page: number;
+    private takeoffShown;
+    private grid?;
+    constructor();
+    private strips;
+    private stripsFor?;
+    private struck;
+    private flipping;
+    private touchY;
+    private takeoffRaf;
+    private observer?;
+    private spins;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private turnPage;
+    private inRoom;
+    private flip;
+    private touchStart;
+    private touchEnd;
+    private pageKeys;
+    private climb;
+    private accelerate;
+    connectedCallback(): void;
+    firstUpdated(): Promise<void>;
+    disconnectedCallback(): void;
+    private play;
+    private meta;
+    private takeoffArt;
+    private breakawayArt;
+    private rouletteArt;
+    private pachinkoArt;
+    private scratchArt;
+    private art;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'fl-lobby': Lobby;
+    }
+}

package/dist/room/mount.d.ts

@@ -0,0 +1,6 @@
+import type { Room, RoomConfig } from './room';
+import './room';
+export declare function mountRoom(host: HTMLElement, config: RoomConfig, origin?: {
+    x: number;
+    y: number;
+}): Room;