@betorigami/games 2.10.1 → 2.11.0

package/dist/translations/zh.json.d.ts

@@ -0,0 +1,406 @@
+declare const _default: {
+  "accessibility": {
+    "sliderValue": "{value} / {max}"
+  },
+  "alerts": {
+    "autobetStarted": "已启动自动投注模式",
+    "autobetStopped": "已停止自动投注模式",
+    "betAmountAboveMaxBet": "最高投注额为{value}",
+    "betAmountBelowMinBet": "最低下注为{value}",
+    "betLimitReached": "已达到投注限额",
+    "errorProcessingBet": "处理您的投注时出现错误。请重试。",
+    "failedToLoadBetData": "加载投注数据失败",
+    "gameError": "处理您的投注时出现错误。请重试。",
+    "insufficientBalance": "余额不足",
+    "maxPayoutExceeded": "超过最大赔付",
+    "notEnoughBalance": "余额不足"
+  },
+  "autobet": {
+    "configureAutobet": "配置 Autobet",
+    "games": "游戏",
+    "games10": "10款游戏",
+    "games100": "100款游戏",
+    "games25": "25款游戏",
+    "games5": "5款游戏",
+    "games50": "50款游戏",
+    "increase": "增加",
+    "infinite": "无限",
+    "onLoss": "亏损时",
+    "onWin": "获胜时",
+    "reset": "重置",
+    "placeBet": "下注 {count} 次",
+    "placeBets": "下注 {count} 次",
+    "startAutobet": "开始自动投注",
+    "stopAutobet": "停止自动投注",
+    "stopOnLoss": "止损",
+    "stopOnProfit": "止盈"
+  },
+  "clipboard": {
+    "linkCopied": "链接已复制到剪贴板！"
+  },
+  "common": {
+    "auto": "自动",
+    "back": "返回",
+    "balance": "余额",
+    "bet": "投注金额",
+    "betAmount": "投注金额",
+    "cancel": "取消",
+    "cashOut": "提现",
+    "classic": "经典",
+    "confirm": "确认",
+    "continue": "继续",
+    "copied": "已复制",
+    "currency": "货币",
+    "deposit": "存款",
+    "disableHotkeys": "禁用快捷键",
+    "disableMaxBet": "禁用最高投注",
+    "enableHotkeys": "启用快捷键",
+    "enableMaxBet": "启用最大投注",
+    "footerNavigation": "页脚导航",
+    "gameInfo": "游戏信息",
+    "gameName": "游戏名称",
+    "getStarted": "开始",
+    "high": "高",
+    "history": "历史",
+    "hotkeys": "快捷键",
+    "id": "ID",
+    "instantBet": "即时投注",
+    "loading": "加载中…",
+    "loadMore": "加载更多",
+    "lobby": "返回大厅",
+    "low": "低",
+    "manual": "手册",
+    "max": "最大",
+    "medium": "中等",
+    "multiplier": "倍数",
+    "opensInNewWindow": "在新窗口中打开",
+    "payout": "派彩",
+    "placeBet": "下注",
+    "profit": "利润",
+    "profitOnWin": "获胜利润",
+    "provablyFair": "可验证公平",
+    "risk": "风险",
+    "roundId": "回合ID",
+    "saveChanges": "保存更改",
+    "shareReplay": "分享回放",
+    "siteInformation": "游戏信息",
+    "space": "SPACE",
+    "support": "支持",
+    "targetMultiplier": "倍数",
+    "thisFieldIsRequired": "此字段为必填项",
+    "timestamp": "时间",
+    "toggleHotkeys": "切换快捷键",
+    "viewFairnessInformation": "查看公平性信息",
+    "viewHistory": "查看历史",
+    "volume": "音量",
+    "winChance": "获胜概率"
+  },
+  "errors": {
+    "dice": {
+      "multiplierRange": "必须在{min}和{max}之间",
+      "winChanceRange": "必须在{min}和{max}之间"
+    },
+    "roulette": {
+      "oppositeBet": "适用投注限制"
+    },
+    "noWheelData": "没有可用的轮盘数据",
+    "requestDropped": "请求已取消"
+  },
+  "fairness": {
+    "activeClientSeed": "活跃客户端种子",
+    "enterClientSeed": "输入客户端种子",
+    "enterProof": "输入证明",
+    "enterPublicKey": "输入公钥",
+    "enterRandomness": "输入随机性",
+    "enterSeed": "输入种子",
+    "info": {
+      "p1": "每一局的结果都来源于可验证的随机性，而不是隐藏的服务器逻辑。我们通过使用您本局独有的数值——gameId、tenantId、tenantUserId、递增的nonce（每完成一局增加一次），以及您的clientSeed，来构建一个确定性的种子。这确保了每一局都是唯一且可复现的：相同的输入 → 相同的随机流 → 相同的结果。",
+      "p2": "该种子根据IETF规范 draft-irtf-cfrg-vrf-15 通过椭圆曲线可验证随机函数（ECVRF）运行。我们的服务器使用其私钥生成一个随机值和一个加密证明（proofString）。任何拥有我们公钥的人都可以独立验证该证明对于给定输入的有效性——从而确认随机性确实来源于该种子且未被篡改。SDK为TypeScript，而核心加密部分通过NAPI-RS使用fastcrypto Rust库，以提升性能和安全性。",
+      "p3": "一旦验证通过，VRF 输出将为确定性随机字节生成器（hashSequence）提供种子。游戏使用确定性且无偏的逻辑将这些字节转换为结果。由于该过程是确定性的，并且每完成一轮 nonce 都会递增，因此你既可以获得可重现的审计（精确重现同一轮），又可以每次获得全新且不重复的随机性。",
+      "p4": "在一局结束后，你拥有输入值（包括你的clientSeed和本局的nonce）、VRF输出、proofString以及我们的公钥。使用任何ECVRF验证器或我们的库来：（1）根据输入值和公钥验证proof；（2）重新生成相同的hashSequence和结果。我们的私钥始终保存在安全服务器上，公钥可以安全地在客户端用于独立校验。",
+      "step1Desc": "我们将 gameId、tenantId、tenantUserId、每轮的 nonce 和你的 clientSeed 组合在一起。相同的输入总是会产生相同的随机流和结果。",
+      "step1Title": "确定性种子",
+      "step2Title": "生成随机数",
+      "step3Desc": "任何人都可以使用我们的公钥验证给定输入的proofString。这可以确认随机性与种子相符且未被篡改。",
+      "step3Title": "验证证明",
+      "step4Title": "推导结果",
+      "step5Title": "复制"
+    },
+    "invalidGame": "提供了无效的游戏类型。",
+    "learnMore": "了解更多",
+    "newClientSeed": "新客户端种子",
+    "noBettingHistory": "无投注记录",
+    "outcomeCalculationInfo": "该游戏采用可验证公平算法，确保结果公平透明。",
+    "proof": "证明",
+    "provablyFair": "公平性",
+    "publicKey": "活跃公钥",
+    "randomness": "随机性",
+    "saveClientSeed": "保存客户端种子",
+    "seed": "种子",
+    "verifyIndependently": "独立验证"
+  },
+  "gameInfo": {
+    "blackjack": {
+      "how1": "设置您的下注金额并下注。",
+      "how2": "您和庄家各发两张牌；庄家的一张牌面朝上。",
+      "how3": "选择要牌（拿一张牌）、停牌（保持手牌）、加倍（双倍下注，拿一张牌）或分牌（如果您有对子）。",
+      "how4": "超过21点意味着爆牌，您将立即输掉。",
+      "how5": "庄家亮出手牌，必须要牌直到达到17或更高。",
+      "how6": "最接近21点而不爆牌的一方获胜；平局退还您的赌注。",
+      "overview": "在不超过21点的情况下比庄家更接近21点来获胜。要牌获取更多卡牌或停牌保持当前手牌。花牌值10点，A可算作1或11。",
+      "provablyFair": "我们的可验证随机性系统生成每次Blackjack发牌。每轮结束后，您可以查看输入和证明，使用我们的公钥验证结果，并重现相同的结果。",
+      "strategyTip": "学习基本策略以减少庄家优势。通常在17以上停牌，8以下要牌，在庄家弱牌时10或11加倍。保持一致的下注大小有助于管理资金波动。"
+    },
+    "baccarat": {
+      "how1": "将筹码放在闲家、庄家或和局上。",
+      "how2": "使用1/2和2X按钮调整筹码价值。",
+      "how3": "下注以发牌。",
+      "how4": "每手牌发两张；根据标准规则可能会抽取第三张牌。",
+      "how5": "最接近9的手牌获胜。闲家赔付2X，庄家赔付1.95X，和局赔付9X。",
+      "overview": "百家乐是一种经典纸牌游戏，您押注哪手牌会赢。最接近9的手牌获胜。花牌和十点牌计为零；A计为一。",
+      "provablyFair": "我们的可验证随机系统生成每次百家乐发牌。每轮结束后，您可以查看输入和证明，用我们的公钥验证结果，并重现相同的结果。",
+      "strategyTip": "庄家和闲家投注提供稳定的赔率，而和局赔付9X但较少出现。根据您的风险偏好组合您的投注。"
+    },
+    "advancedDice": {
+      "how1": "选择你的投掷模式：内部、外部或介于两者之间。",
+      "how2": "拖动滑块来定义你的获胜区域。",
+      "how3": "设置你的投注金额并下注。",
+      "how4": "生成一个0到100之间的随机数。",
+      "how5": "如果结果落在你选择的区域内则获胜。",
+      "overview": "高级骰子让你设置自定义获胜区域。选择内部在结果落入你的范围内时获胜，外部在结果超出你的范围时获胜，或选择介于两者之间分成两个获胜区域。",
+      "provablyFair": "我们可验证的随机性系统生成每个高级骰子结果。每轮结束后，你可以查看输入和证明，用我们的公钥验证结果，并重现相同的结果。",
+      "strategyTip": "较宽的区域提供更频繁的获胜但乘数较小。较窄的区域风险更高但支付更多。介于两者之间模式让你可以针对两个范围制定灵活的策略。"
+    },
+    "diamonds": {
+      "how1": "设置您的投注金额并下注。",
+      "how2": "从固定的宝石类型中揭示出五颗Diamonds。",
+      "how3": "您的结果将按照扑克手牌进行评估：对子、两对、三条、葫芦、四条和五条。",
+      "how4": "每种牌型都有其对应的倍数；高价值牌型奖励更高的倍数，而没有成型牌则支付0X。",
+      "how5": "您的奖金是您的投注额乘以所示倍数所得出的结果。",
+      "overview": "Diamonds 是一款五转轴连线游戏。每一轮会从不同类型的宝石中揭示五颗钻石。你的目标是获得类似扑克的组合——对子、三条、葫芦等。",
+      "provablyFair": "我们的可验证随机系统选择每个钻石的结果。每一轮结束后，您可以查看底层的随机值和证明，使用我们的公钥验证结果，并复现相同的牌局。",
+      "strategyTip": "Diamonds是一款高波动性、固定赔率的游戏，你将在其中追逐高额的扑克式牌型。你的主要操控方式是决定你的激进程度。如果你想挺过低迷期，可以使用较小且稳定的投注；如果你在追逐高价值牌型时，可以偶尔提高你的投注额度。"
+    },
+    "dice": {
+      "how1": "选择掷骰低于还是高于。",
+      "how2": "设置你的目标数字。",
+      "how3": "设置您的投注金额并下注。",
+      "how4": "我们生成一个随机结果（在游戏中以0–99.99的刻度显示）。",
+      "how5": "如果结果在您选择的范围内，您就获胜。",
+      "how6": "您的奖金是投注额乘以显示的倍数，倍数会随着您移动滑块而更新。",
+      "overview": "设置一个目标数字，并选择掷骰结果是低于还是高于该数字。移动滑块会改变你的获胜几率和倍数——几率越高，倍数越低，几率越低，倍数越高。每一轮都是游戏刻度上的一次独立掷骰。",
+      "provablyFair": "我们的可验证随机系统生成每一次Dice掷骰结果。每轮结束后，您都可以查看输入和证明，使用我们的公钥验证结果，并复现相同的结果。",
+      "strategyTip": "选择你的波动性。较低的中奖概率带来更高的倍数，但中奖次数较少。较高的中奖概率带来较低的倍数，但中奖更为频繁。根据你的资金规模调整下注金额，以获得更平稳的波动。"
+    },
+    "keno": {
+      "how1": "在1–40的棋盘上选择1–10个格子。",
+      "how2": "设置您的投注金额并下注。",
+      "how3": "我们抽取了10个中奖号码；您的匹配号码已被高亮显示。",
+      "how4": "奖金取决于你选择了多少格子以及命中了多少次——请查看赔率表。",
+      "how5": "你选择的数字数量不会超过你所选的数量，最多可以选择10个。",
+      "overview": "选取你的幸运数字并尝试匹配开奖结果。你可以从1到40中选择1到10个数字，然后我们会抽取10个数字。你选中的数字越多，奖金就越高。",
+      "provablyFair": "我们的可验证随机系统生成每一次Keno开奖。每一轮结束后，您都可以查看输入和证明，使用我们的公钥验证结果，并复现相同的结果。",
+      "strategyTip": "选择你的波动性。选择较少的点位意味着中奖更少但倍数更高。选择更多的点位则中奖更频繁但每次的平均回报较低。中间范围则在中奖率和奖金之间取得平衡。根据你的风险偏好和资金状况调整你的投注额度。"
+    },
+    "limbo": {
+      "how1": "设置您的目标倍数。",
+      "how2": "设置您的投注金额并下注。",
+      "how3": "我们生成一个随机结果乘数。",
+      "how4": "如果结果大于或等于你的目标，你就获胜。",
+      "how5": "您的奖金为下注金额乘以您的目标倍数；否则，您将失去您的下注。",
+      "overview": "在Limbo中，你设置你想要的赔付，游戏会随机抽取一个结果倍率。如果结果至少达到你的目标，你就赢了。如果低于目标，你就输了。更高的获胜概率会降低倍率，更低的获胜概率会提高倍率。",
+      "provablyFair": "我们的可验证随机性系统生成每一个Limbo结果。每一轮结束后，您都可以查看输入和证明，使用我们的公钥验证结果，并复现相同的结果。",
+      "strategyTip": "较低的目标更容易获胜但支付较少，而较高的目标很少命中但支付更多。可以考虑每个会话设定一个固定目标，或者偶尔尝试高赔率目标，并且保持投注金额一致以管理波动。"
+    },
+    "limitContent": "此游戏可获得的最大倍数为{multiplier}X。可获得的最高奖金为{payout}",
+    "limitTitle": "限制",
+    "mines": {
+      "how1": "选择本轮的地雷数量。",
+      "how2": "设置您的投注金额并下注。",
+      "how3": "点击方块揭示它们：安全方块会增加你的倍率；地雷会结束本轮。",
+      "how4": "您可以随时提现以锁定您当前的倍数。",
+      "how5": "当你提现时，你的奖金是投注额乘以当前的倍率。",
+      "how6": "当你提现或揭示地雷时，本轮结束。",
+      "overview": "Mines是一款关于选择安全方块并决定何时提现的游戏。在回合开始前，选择要在棋盘上隐藏多少个地雷。每揭开一个安全方块，你的倍率就会增加。踩到地雷，回合立即结束且没有奖金。",
+      "provablyFair": "我们的可验证随机系统会生成每个棋盘的隐藏地雷布局。每一轮结束后，你都可以查看输入和证明，使用我们的公钥验证结果，并复现相同的结果。",
+      "strategyTip": "选择你的波动性。更少的Mines意味着更安全的揭示和每步更小的倍数。更多的Mines则带来更高风险的揭示和更大的倍数。设定目标或使用止损来管理波动。保持一致的投注额度和有纪律的提现有助于控制方差。"
+    },
+    "plinko": {
+      "how1": "Select your risk level and number of rows.",
+      "how2": "Set your bet amount and place your bet.",
+      "how3": "The ball drops and bounces through the pegs.",
+      "how4": "Your payout is bet × the multiplier of the bin where the ball lands.",
+      "how5": "Center bins pay less; edge bins pay more based on your chosen risk level and row count.",
+      "overview": "Drop a ball and watch it bounce down through a field of pegs. Choose your risk level and number of rows before each drop—higher risk and more rows unlock bigger edge multipliers but make them harder to hit.",
+      "provablyFair": "Our verifiable randomness system generates every Plinko drop. After each round, you can view the inputs and proof, verify the result with our public key, and reproduce the same outcome.",
+      "strategyTip": "Low risk offers steady, smaller wins. Medium risk balances frequency and payout. High risk targets rare but massive edge multipliers. More rows spread the multipliers across more bins, increasing maximum potential but reducing the chance of hitting the edges."
+    },
+    "rtpContent": "本游戏的返还率（RTP）为{rtpValue}%。",
+    "rtpTitle": "RTP：{rtpValue}%",
+    "strategyTitle": "策略",
+    "tutorial": "教程",
+    "wheel": {
+      "how1": "选择你的风险等级和分段数量。",
+      "how2": "设置您的投注金额并下注。",
+      "how3": "轮盘旋转并停在一个区域。",
+      "how4": "您的奖金是投注额乘以指针停留在转盘上的倍数。",
+      "how5": "每个区段都有不同的倍数，具体取决于你选择的风险等级和区段数量。",
+      "overview": "转动转盘，观察它停在哪里。在每次旋转前选择你的风险等级和分段数——较低的风险会带来更频繁但倍数较小的获胜；较高的风险则带来较少但倍数更大的获胜。",
+      "provablyFair": "我们的可验证随机系统生成每一次Wheel的结果。每轮结束后，您都可以查看输入和证明，使用我们的公钥验证结果，并复现相同的结果。",
+      "strategyTip": "低风险提供稳定且较小的胜利。中等风险在中奖频率和支付额之间取得平衡。高风险则瞄准罕见但巨大的倍数。更多分段提高最高潜力，但会降低中奖频率。"
+    },
+    "roulette": {
+      "how1": "点击网格将筹码放置在您选择的投注上。",
+      "how2": "使用1/2和2X按钮调整每次点击的投注金额。",
+      "how3": "下注以旋转轮盘。",
+      "how4": "球落在0-36之间的随机数字上（美式还包括00）。",
+      "how5": "中奖的投注按赔率支付；其他所有筹码都会输掉。",
+      "overview": "在投注网格上放置筹码并旋转轮盘。投注单个数字、数字组、颜色或奇数/偶数。球落入随机格子，匹配的投注按赔率支付。",
+      "provablyFair": "我们的可验证随机系统生成每次轮盘旋转。每轮结束后，您可以查看输入和证明，用我们的公钥验证结果，并重现相同的结果。",
+      "strategyTip": "外围投注（红/黑、奇/偶）提供接近50%的中奖率，赔率为2倍。单个数字的内部投注最高可赔36倍，但很少中奖。分散您的筹码以平衡风险和回报。"
+    },
+    "blitz": {
+      "overview": "Blitz 是一款不重复抽牌游戏。选择要抽取的牌数，如果每张翻开的牌都不重复即可获胜。牌数越多，乘数越高，抽到重复牌的风险也越高。",
+      "how1": "选择你想追求的不重复牌数。",
+      "how2": "设置下注金额并下注。",
+      "how3": "牌会在牌组网格中逐张翻开。",
+      "how4": "如果每张翻开的牌都不重复，你就获胜。",
+      "how5": "第一张重复牌会结束本轮，且没有赔付。",
+      "strategyTip": "较少的牌数更容易命中，但乘数较低。较多的牌数波动更大，但可能带来高得多的赔付。请根据所选牌数调整下注金额。",
+      "provablyFair": "我们的可验证随机系统会为每一轮 Blitz 生成牌流。每轮结束后，你可以查看输入和证明，用我们的公钥验证抽牌，并复现相同结果。"
+    }
+  },
+  "games": {
+    "advancedDice": {
+      "between": "之间",
+      "boundsLower": "下限",
+      "boundsUpper": "上限",
+      "inside": "内部",
+      "outside": "外部",
+      "rollMode": "掷骰模式",
+      "secondBoundsLower": "第二下限",
+      "secondBoundsUpper": "第二上限"
+    },
+    "baccarat": {
+      "chipValue": "筹码价值",
+      "player": "闲",
+      "banker": "庄",
+      "tie": "和",
+      "totalBetAmount": "总投注额",
+      "selectChip": "请至少下注一次",
+      "slowReveal": "慢速揭牌"
+    },
+    "blackjack": {
+      "seats": "座位",
+      "hit": "要牌",
+      "stand": "停牌",
+      "split": "分牌",
+      "double": "加倍",
+      "standard": "标准",
+      "sideBet": "边注",
+      "blackjackLabel": "二十一点",
+      "insuranceLabel": "保险",
+      "blackjackPays": "二十一点赔付 3 比 2",
+      "insurancePays": "保险赔付 2 比 1",
+      "exactPair": "完美对子",
+      "coloredPair": "同色对子",
+      "mixedPair": "混合对子",
+      "suitedTrips": "同花三条",
+      "straightFlush": "同花顺",
+      "threeOfAKind": "三条",
+      "straight": "顺子",
+      "flush": "同花",
+      "sideBetPairBonus": "对子奖金",
+      "sideBetThreeCardBonus": "三张奖金",
+      "sideBetOnboarding": {
+        "step1Title": "边注",
+        "step1Body": "与主注一起下的可选投注。选择对子奖金、三张奖金或两者兼选。",
+        "step2Title": "对子奖金",
+        "step2Body": "使用你的前两张牌。如果它们的点数相同则赢，同色对子和完美对子有更高的赔率。",
+        "step3Title": "三张奖金",
+        "step3Body": "将你的两张牌与庄家的明牌组合。同花、顺子或三条即可赢。",
+        "step4Title": "独立赔付",
+        "step4Body": "两项投注都在初始发牌时结算，独立于你的主手牌赔付。",
+        "openingCardsOnly": "发牌时结算",
+        "separateFromMainHand": "独立于主手牌",
+        "pairBonusCards": "你的前2张牌",
+        "threeCardBonusCards": "你的2张牌 + 庄家明牌",
+        "pairBonusResults": "混合、同色或完美对子",
+        "threeCardBonusResults": "同花、顺子、三条或更好"
+      },
+      "buyInsurance": "买保险",
+      "noInsurance": "不买保险",
+      "insuranceBelowMinimumBet": "保险下注额将低于最低下注额"
+    },
+    "blitz": {
+      "cardsRemaining": "剩余牌数",
+      "decreasePicks": "减少选择",
+      "increasePicks": "增加选择",
+      "uniqueCards": "不重复牌数"
+    },
+    "dice": {
+      "rollOver": "大于",
+      "rollUnder": "掷出点数低于"
+    },
+    "keno": {
+      "autoPick": "自动选择",
+      "clearTable": "清除",
+      "kenoGameGrid": "Keno游戏网格",
+      "kenoNumber": "Keno号码 {value}",
+      "selectAtLeastOneTile": "请选择至少一个方块",
+      "selectTileToAutobet": "请选择至少一个方块"
+    },
+    "limbo": {
+      "multiplierError": "必须在{min}和{max}之间",
+      "targetMultiplier": "倍数",
+      "winChanceError": "必须在{min}和{max}之间"
+    },
+    "mines": {
+      "cashout": "提现",
+      "gem": "宝石",
+      "gems": "宝石",
+      "mine": "挖矿",
+      "mines": "扫雷",
+      "nextGem": "下一个宝石",
+      "selectRandomTile": "选择随机方块",
+      "selectTileToAutobet": "请选择至少一个方块",
+      "tile": "瓷砖",
+      "unrevealed": "未揭示"
+    },
+    "roulette": {
+      "chipValue": "筹码价值",
+      "totalBetAmount": "总投注额"
+    },
+    "wheel": {
+      "segments": "分段"
+    }
+  },
+  "hotkeys": {
+    "clearBets": "清除投注",
+    "doubleBet": "加倍投注金额",
+    "doubleChipValue": "双倍筹码价值",
+    "doubleTotalBet": "双倍总投注",
+    "halveBet": "减半投注金额",
+    "halveChipValue": "减半筹码价值",
+    "halveTotalBet": "减半总投注",
+    "higherTarget": "更高目标",
+    "info": "当启用快捷键时，它们将在此游戏中保持开启，直到被禁用。尽管某些游戏可能有相似的按键绑定，仍然建议为每个游戏确认快捷键。",
+    "lowerTarget": "下限目标",
+    "makeBet": "下注",
+    "resetChipValue": "重置筹码价值",
+    "toggleWinCondition": "切换获胜条件",
+    "undo": "撤销",
+    "clear": "清除",
+    "zeroBet": "零投注金额"
+  },
+  "modals": {
+    "betResult": "投注结果",
+    "fairnessAndHistory": "公平性与历史",
+    "gameArea": "游戏区",
+    "gameControls": "游戏控制",
+    "gameInfo": "游戏信息"
+  }
+}
+;
+
+export default _default;

package/dist/utils/active-elements.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use a generator so we can iterate and possibly break early.
+ * @example
+ *   // to operate like a regular array. This kinda nullifies generator benefits, but worth knowing if you need the whole array.
+ *   const allActiveElements = [...activeElements()]
+ *
+ *   // Early return
+ *   for (const activeElement of activeElements()) {
+ *     if (<cond>) {
+ *       break; // Break the loop, dont need to iterate over the whole array or store an array in memory!
+ *     }
+ *   }
+ */
+export declare function activeElements(activeElement?: Element | null): Generator<Element>;
+export declare function getDeepestActiveElement(): Element | undefined;

package/dist/utils/animate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Animates an element using keyframes. Returns a promise that resolves after the animation completes or gets canceled.
+ */
+export declare function animateTo(el: HTMLElement, keyframes: Keyframe[], options?: KeyframeAnimationOptions): Promise<unknown>;
+/** Parses a CSS duration and returns the number of milliseconds. */
+export declare function parseDuration(delay: number | string): number;
+/** Tells if the user has enabled the "reduced motion" setting in their browser or OS. */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * Stops all active animations on the target element. Returns a promise that resolves after all animations are canceled.
+ */
+export declare function stopAnimations(el: HTMLElement): Promise<unknown[]>;
+/**
+ * We can't animate `height: auto`, but we can calculate the height and shim keyframes by replacing it with the
+ * element's scrollHeight before the animation.
+ */
+export declare function shimKeyframesHeightAuto(keyframes: Keyframe[], calculatedHeight: number): {
+    height: string | number | null | undefined;
+    composite?: CompositeOperationOrAuto;
+    easing?: string;
+    offset?: number | null;
+}[];

package/dist/utils/animation-registry.d.ts

@@ -0,0 +1,24 @@
+export interface ElementAnimation {
+    keyframes: Keyframe[];
+    rtlKeyframes?: Keyframe[];
+    options?: KeyframeAnimationOptions;
+}
+export interface ElementAnimationMap {
+    [animationName: string]: ElementAnimation;
+}
+export interface GetAnimationOptions {
+    /**
+     * The component's directionality. When set to "rtl", `rtlKeyframes` will be preferred over `keyframes` where
+     * available using getAnimation().
+     */
+    dir: string;
+}
+/**
+ * Sets a default animation. Components should use the `name.animation` for primary animations and `name.part.animation`
+ * for secondary animations, e.g. `dialog.show` and `dialog.overlay.show`. For modifiers, use `drawer.showTop`.
+ */
+export declare function setDefaultAnimation(animationName: string, animation: ElementAnimation | null): void;
+/** Sets a custom animation for the specified element. */
+export declare function setAnimation(el: Element, animationName: string, animation: ElementAnimation | null): void;
+/** Gets an element's animation. Falls back to the default if no animation is found. */
+export declare function getAnimation(el: Element, animationName: string, options: GetAnimationOptions): ElementAnimation;

package/dist/utils/blur-active-element.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Calls the blur method on the current active element if it is a child of the provided element.
+ * Needed for fixing a11y errors in console.
+ * @see https://github.com/shoelace-style/shoelace/issues/2283
+ * @param elm The element to check
+ */
+export declare const blurActiveElement: (elm: HTMLElement) => void;

package/dist/utils/event.d.ts

@@ -0,0 +1,2 @@
+/** Waits for a specific event to be emitted from an element. Ignores events that bubble up from child elements. */
+export declare function waitForEvent(el: HTMLElement, eventName: keyof GlobalEventHandlersEventMap): Promise<void>;

package/dist/utils/focus-trap.d.ts

@@ -0,0 +1,24 @@
+export default class FocusTrap {
+    element: HTMLElement;
+    isExternalActivated: boolean;
+    tabDirection: 'forward' | 'backward';
+    currentFocus: HTMLElement | null;
+    previousFocus: HTMLElement | null;
+    elementsWithTabbableControls: string[];
+    constructor(element: HTMLElement);
+    /** Activates focus trapping. */
+    activate(): void;
+    /** Deactivates focus trapping. */
+    deactivate(): void;
+    /** Determines if this modal element is currently active or not. */
+    isActive(): boolean;
+    /** Activates external modal behavior and temporarily disables focus trapping. */
+    activateExternal(): void;
+    /** Deactivates external modal behavior and re-enables focus trapping. */
+    deactivateExternal(): void;
+    private checkFocus;
+    private handleFocusIn;
+    private possiblyHasTabbableChildren;
+    private handleKeyDown;
+    private handleKeyUp;
+}

package/dist/utils/game-layout-style.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates the game layout style based on viewport dimensions and game data
+ * @param gameData - The game data containing scale and mainWidth properties
+ * @returns The calculated CSS style string for the game layout
+ */
+export declare function calculateGameLayoutStyle(gameData: {
+    scale: number;
+    mainWidth: number;
+}): string;

package/dist/utils/scroll.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns an element's offset relative to its parent. Similar to element.offsetTop and element.offsetLeft, except the
+ * parent doesn't have to be positioned relative or absolute.
+ *
+ * NOTE: This was created to work around what appears to be a bug in Chrome where a slotted element's offsetParent seems
+ * to ignore elements inside the surrounding shadow DOM: https://bugs.chromium.org/p/chromium/issues/detail?id=920069
+ */
+export declare function getOffset(element: HTMLElement, parent: HTMLElement): {
+    top: number;
+    left: number;
+};
+/**
+ * Prevents body scrolling. Keeps track of which elements requested a lock so multiple levels of locking are possible
+ * without premature unlocking.
+ */
+export declare function lockBodyScrolling(lockingEl: HTMLElement): void;
+/**
+ * Unlocks body scrolling. Scrolling will only be unlocked once all elements that requested a lock call this method.
+ */
+export declare function unlockBodyScrolling(lockingEl: HTMLElement): void;
+/** Scrolls an element into view of its container. If the element is already in view, nothing will happen. */
+export declare function scrollIntoView(element: HTMLElement, container: HTMLElement, direction?: 'horizontal' | 'vertical' | 'both', behavior?: 'smooth' | 'auto'): void;

package/dist/utils/slot.controller.d.ts

@@ -0,0 +1,23 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/** A reactive controller that determines when slots exist. */
+export declare class HasSlotController implements ReactiveController {
+    host: ReactiveControllerHost & Element;
+    slotNames: string[];
+    constructor(host: ReactiveControllerHost & Element, ...slotNames: string[]);
+    private hasDefaultSlot;
+    private hasNamedSlot;
+    test(slotName: string): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private handleSlotChange;
+}
+/**
+ * Given a slot, this function iterates over all of its assigned element and text nodes and returns the concatenated
+ * HTML as a string. This is useful because we can't use slot.innerHTML as an alternative.
+ */
+export declare function getInnerHTML(slot: HTMLSlotElement): string;
+/**
+ * Given a slot, this function iterates over all of its assigned text nodes and returns the concatenated text as a
+ * string. This is useful because we can't use slot.textContent as an alternative.
+ */
+export declare function getTextContent(slot: HTMLSlotElement | undefined | null): string;

package/dist/utils/tabbable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the first and last bounding elements that are tabbable. This is more performant than checking every single
+ * element because it short-circuits after finding the first and last ones.
+ */
+export declare function getTabbableBoundary(root: HTMLElement | ShadowRoot): {
+    start: HTMLElement;
+    end: HTMLElement;
+};
+export declare function getTabbableElements(root: HTMLElement | ShadowRoot): HTMLElement[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@betorigami/games",
-  "version": "2.10.1",
+  "version": "2.11.0",
   "author": "",
   "license": "UNLICENSED",
   "description": "",
@@ -21,18 +21,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "tsc": "tsc",
-    "build": "bun run build.ts",
-    "build:static": "vite build --config vite.static.config.js",
-    "preview:static": "vite preview --outDir static-dist",
-    "watch": "vite",
-    "bundlemon": "bundlemon --subProject games",
-    "e2e": "bun playwright test e2e",
-    "e2e:debug": "bun playwright test e2e/dice/dice* --headed",
-    "test": "bun test test",
-    "format": "biome format --write"
-  },
   "dependencies": {
     "@betorigami/game-calculations": "6.0.2",
     "@lit/context": "^1.1.5",
@@ -48,6 +36,7 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@types/big.js": "^6.2.2",
     "@types/matter-js": "^0.18.2",
+    "@types/node": "^26.4.1",
     "async": "^3.2.6",
     "glob": "^11.0.2",
     "mkdirp": "^3.0.1",
@@ -55,6 +44,20 @@
     "typescript": "^5.8.3",
     "underscore": "^1.13.7",
     "vite": "^6.3.5",
-    "vite-plugin-dts": "^4.5.4"
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "tsc": "tsc",
+    "build": "vite build",
+    "build:static": "vite build --config vite.static.config.js",
+    "preview:static": "vite preview --outDir static-dist",
+    "watch": "vite",
+    "bundlemon": "bundlemon --subProject games",
+    "e2e": "playwright test e2e",
+    "e2e:debug": "playwright test e2e/dice/dice* --headed",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "format": "biome format --write"
   }
-}
+}