Stake.us / 前端主报告2026-10-13 · 逐文件清单 · 后端接口附录
FRONTEND / SOURCE ANALYSIS / REA MCP

前端实现与模块逻辑全部已抓源码的解析、结构和业务链路

前端是主线:界面组件、共享状态、表单、币种、聊天、游戏和计算器。后端仅作为独立接口附录,区分客户端协议与未知服务端实现。

774 个 JS 全部解析76 个 CSSREA MCP 扫描 + 定向深读逐文件分析层次
01

先看结论和分析范围

报告回答“它怎么实现、模块怎么协作”,而不仅列出下载文件。

前端骨架

SvelteKit 路由 + Vite 动态加载;Svelte 编译组件、共享 store 与配置分支共同组织界面。

游戏逻辑

Dice 把输入联动、手动/自动状态机、请求、结果展示分层。随机结果来自响应;界面不是本地开奖器。

公平性计算

单独的离线验证路径:输入 seed → HMAC → 字节 → 数值 → 游戏映射。它解释已有结果,不能获知隐藏 seed。

本轮范围:全部774个已抓JS均完成AST解析和REA扫描;76份CSS完成词法索引与重点组件分析。深读覆盖Dice、首页、外壳、表单、自动补全、币种、聊天、OAuth、配置和计算器。逐文件清单标识扫描与深读层次,不把所有动态语义称为已解决。

逐文件前端分析清单 · 后端接口附录(单独阅读)

02

整体架构:外壳、路由、业务和数据

共享能力决定跨页面行为;组件文件名并不直接代表完整功能。

01启动

start/app 加载初始页面状态

02路由与布局

匹配路径,组合 layout 与 leaf node

03业务组件

目录、游戏、弹窗、计算器

04共享能力

store、会话、请求、余额、样式

站点外壳导航 / Header / 左右侧栏 / 弹窗入口
页面模块首页推荐游戏共享壳 → Dice计算器
状态与控制URL / session / config输入 store / 状态机计算 store
数据入口GraphQL游戏 HTTP / 余额事件WebCrypto 本地计算

这个架构说明为什么“游戏页面”不等于一个独立 JS 文件:路由 node 通常只是薄包装,实际实现位于多个 chunks。报告按业务链路命名模块;原文件名继续保留,便于核查。

应用入口源码 · Dice 薄包装 D01

03

路由与按需加载

声明、已下载和已分析是三个不同层次;下方清单分别标识。

179路由声明
234node 加载器
1,634依赖表条目

入口的 node loader 使用动态 import。Vite helper 把依赖索引映射为 URL,插入 JS 的 modulepreload 和 CSS 的 stylesheet,避免重复链接,并在预载失败时发出 vite:preloadError。CSS 会等待 load/error,随后再执行实际 import;新链接读取 CSP nonce。

路径 /casino/games/dice
  → 共享布局 2 → Casino 布局 10 → 游戏布局 13
  → 页面 node 102
  → chunks/B_cV99S-.mjs 的 Dice 组件

配置决定一些路径别名:例如 deposits/purchases、withdrawals/redemptions,以及 responsible-gaming/gambling。包含 Sports 路由只证明构建有这一分支,不能证明当前 Stake.us 配置开放它。

预载 helper · 完整路由映射

搜索全部路由与已抓取页面

路径共享布局leaf源码
04

共享布局与游戏页面装配

在“具体游戏”上方,还有一层业务壳处理元数据、布局和可用状态。

共享游戏壳先获取游戏元数据,再决定页面内容、不可用状态和旁边的推荐区域。它负责“这个游戏能否显示,以及周边界面怎么摆”;Dice 组件负责具体游戏输入和结果。

元数据

读取 slug 对应游戏、收藏、SEO、功能开关与相关状态。已有游戏数据写入共享 game store,使详情与推荐区域读取同一对象。

显示分支

没有游戏 → not-found;active=false → not-active。代码还有允许完成未结束轮次的分支,需条件检查,不能概括成可玩任何停用游戏。

布局联动

剧院模式读取共享开关;进入游戏页时记录、调整侧栏状态。移动端 /play 与桌面布局有不同显示条件。

站点配置、会话和身份验证弹窗属于外壳层。公开构建里出现账户组件和条件分支,说明代码已经随包分发;这不等于账户权限或后端数据已开放。

共享游戏布局源码 · 详见 L 系列证据

05

首页、搜索与弹窗如何协作

目录数据经过统一适配;搜索和弹窗通过独立状态与延迟组件接入外壳。

首页不是一个目录请求

首页 loader 并发拼接 11 类数据:VIP、recent、trending、在线人数、sports 分支、SEO、sweeps 集合、poker、CMS heroes、活动窗口和 personalised 推荐。共享 Promise helper 将单项失败降级为 undefined,使其他数据继续返回。

适配层把 recent、trending、personalised、sports 与 Originals 统一转成 group/cards。个性化推荐按 isBlocked 升序排列,并保留 modelVersion/sequenceId;trending 读取 recommended-slots,offset=0、limit=50、排序 popular7d。渲染层依据 meta.isAuthenticated 选择不同首屏。

L02 L09 L10 L11 L12

搜索是独立叠层

桌面 Cmd+K / Ctrl+K 切换全局搜索开关;打开时才注册 Escape 关闭。开关为真才动态 import 搜索组件,加载失败会收起叠层。本次缺少 Csd-SZM5.mjs,因此搜索查询、缓存和分页逻辑没有恢复。此前页面交互观察只能证明表现,不能补成缺失源码。

L16 L17

弹窗状态进入 URL

外壳从 query.modal 读取弹窗名,按需加载注册表,将全部 query 参数传为 modalProps。定义可声明 restricted(meta)、persistent、遮罩和禁止外部点击关闭。Escape 经过统一关闭函数;非 persistent 弹窗关闭时移除 URL 状态。

访客点击收藏/关注/最近游戏等入口,共享链接组件会 preventDefault 并打开注册弹窗。这是页面入口门控;不能把它当作完整后端权限验证。

L13 L14 L15
06

共享状态:侧栏、偏好、存储和上下文

页面之间共享偏好与上下文,但每类状态有自己的存储和能力校验。

左侧栏先取配置/视口默认值,再恢复cookie中的expanded/minimized。右侧栏接受chat、betslip、betsListBoard、hidden、recommendations白名单,禁用chat时降级hidden。在窄屏切换右栏会缩左栏,切左栏会隐藏右栏;通知widget有独立开关。

共享存储包装区分local/session/page作用域。浏览器存储试写失败则退回内存;cookie store会合并默认对象和已存对象,并提供hydrate。reactive store订阅变化自动持久化,不是每个页面各自手写保存逻辑。

session store从组件context获取真实底层store;在绑定前set/update会抛错。这一边界让会话使用依附页面上下文,而不是任意模块直接修改一个全局变量。

Service Worker代码可确认classic注册、ready/active等待和10秒边界;实际service-worker.js未抓到,缓存与离线策略仍未知。

UI01 UI02 UI03 UI04 UI05 UI06 UI07 UI08 UI09
07

表单与自动补全:输入、验证、提交、错误

验证不是每个字符都立即报错;提交和失焦改变验证时机。

01输入状态

value / touched / focus

02schema校验

按字段validateAt

03整表提交

并发验证全部字段

04反馈

翻译错误 / 定位首项

字段还保存error、validating、validateOnChange等状态。第一次改值并失焦之后,开启后续change校验;提交设置isSubmitting,并行验证每个字段,只有所有结果为null才执行onSubmit。无效时调用onInvalidSubmit,可将首个错误滚到视口中间。reset同时重置值、touched和校验时机。

错误信息以key/values或既有message对象进入i18n,动态min/max等参数并非拼接硬编码文案。

自动补全独立组件默认防抖300ms;cleanup取消旧timeout,异步getOptions仅在仍是当前任务时回填。Up/Down循环选择,Enter等待items后确认,Escape关闭;选择通过getString回填,blur清理监听和建议层。

这是通用autocomplete组件的真实机制;缺失的全局搜索Csd-SZM5.mjs是否复用它、采用何种请求/缓存,不能据此直接断言。
UI10 UI11 UI12 UI13 UI14 UI15 UI16
08

币种与金额展示:真实币、展示币、汇率矩阵

显示金额不等于真实余额;前端把计算、偏好和图标加载分别管理。

实际游戏currency与currencyView是两个store,hideZeroBalances是另一项偏好,均通过currency命名空间cookie保存。展示crypto时转换率为0;其他视图从rates[actual][view]派生。actual到USD另有独立派生,不应把两者都称为账户币种。

currencyConfiguration.baseRates在前端展开成矩阵:源币baseRate ÷ 目标币baseRate。没有新配置时保留旧矩阵。登录用户和访客采用不同展示币偏好来源。

列表没有搜索时可以隐藏零余额;输入搜索后忽略零余额过滤,把名称与输入去掉非字母数字并转小写再includes。选币按钮调用changeCurrency并关闭选择层,按钮本身不承担余额请求。

币种图标动态import完成后检查active和当前loader,防止快速换币显示旧图标。切换实际交易币种还会停止游戏自动模式,形成跨模块联动。

UI18 UI19 UI20 UI21 UI22 UI23 UI24 D24
09

聊天模块:快照、实时订阅、发送和限速

历史快照和增量订阅需要明确接续;输入清空也要能在失败后恢复。

进入频道先清删除记录与消息列表,拉历史后reverse,并在loading结束后打开就绪门。chatMessages订阅只在就绪后追加,保留旧消息尾部50项并按id去重;删除订阅从本地列表剔除对应消息。

发送前检查trim后非空、原文长度不超过160。/开头走命令注册表;普通消息先清输入并设置loading,再发携带chatId/message/replyId的mutation。错误会恢复原文;成功清reply并结束loading。命令建议按角色与hidden配置过滤。

频道偏好保存在localStorage,结合频道类型、locale与国家兜底选择;IN优先hi,否则英文再取首项。Please slow down错误触发每频道倒计时,间隔来自publicChats.messageInterval,已有倒计时不重复启动。

上述是前端代码的消息处理逻辑。本轮没有发送消息、订阅真实私人会话或验证服务端限速策略。
UI27 UI28 UI29 UI30 UI31 UI32
10

功能开关、语言与登录入口

同一个生产包里包含多产品能力,实际展示仍受配置和上下文约束。

Feature flag按name缓存在前端字典。单项读取先命中缓存,miss才请求;批量结果覆盖字典,fetchAll的这一调用为limit50/offset0。代码出现“all”的名字不证明自动翻页取尽全部开关。

支付能力有全局enabled与beta名单分支,部分选择还依赖父layout的KYC user id。这些是客户端路由和功能选择,不足以推断服务端授权。

语言切换先set locale,再重建pathname导航;Lingui运行时提供missing事件、message/id fallback和Intl number/date格式化。

OAuth popup每100ms检查closed或完成状态,退出清interval、关闭窗口、取消订阅。Google在配置允许时先尝试redirect,携当前path/search/hash的returnTo;失败再回退popup。前端可说明入口和生命周期,无法恢复身份提供方后台。

地址表单仅恢复保存值中的字符串字段。推广Fingerprint初始化要求publicApiKey、region和attribution flag都满足;异常降级undefined。该第三方集成代码并不是博彩后端实现。

UI25 UI26 UI33 UI34 UI35 UI36 UI37 UI38 UI39
11

组件设计与库边界

将框架、工具库、资产注册表和业务组件拆开,才不会把整个chunk都当作自研逻辑。

根layout明确输出Svelte 5标识;精确patch版本未确定。全局CSS的layer和--tw-*与Tailwind 4结构相容,但缺少准确版本标记,保留为推断。XState、Howler、Lodash与Datadog有可定位的库边界;库内部请求、错误和事件不能直接当成Stake业务协议。

76份CSS已建立tokens、media、font-face和keyframes索引。Edge语义颜色映射slateNavy调色板;常规字体proxima-nova,技术字体JetBrains Mono。header60px、移动footer68px及safe-area变量支持外壳适配。

768px以上隐藏移动底栏;移动底栏固定四等分。GameCard在hover设备上移4%,触屏改用.clicked显示入口;封面比例由134.146% padding-top实现。input的disabled/invalid/readonly/focus、图标与按钮拼接圆角来自共享组件样式。

图标注册表动态import并缓存,失败fallback;部分loader检查当前icon防过期。声音包装订阅每游戏volume/enabled;Howler是底层播放引擎。共享游戏wrapper用宽度设置minHeight与scale,并负责挂载/清理事件。

SUP01 SUP04 SUP05 SUP06 SUP07 SUP08 SUP10 SUP11 SUP12 SUP13 SUP14 SUP15 SUP16 SUP18 SUP22 SUP24 SUP28
12

Dice 输入:三个数值怎样联动

输入变化首先改变本地状态;最终结果仍来自服务端响应。

源码中的核心关系胜率 = above ? 100 − target : target倍数 = 99 ÷ 胜率默认 target 50.50 / above → 胜率 49.50% → 倍数 2.0000

target、condition、chance、payout 各自是 store,但不是彼此独立:改 target 会同步胜率和倍数;改倍数会反推 target;改胜率也会反推 target。切换 above/below 同时执行 target = 100 − target,保持胜率。

target 常规显示两位、chance/payout 显示四位。滑块范围 2–98,而数字输入的限制不同:胜率 .01–98,倍数 1.0102–9900。它们是客户端约束,服务端是否采取相同验证未实测。

报告内的纯公式演示,未连接网站或下注接口。

收益预览是 amount × multiplier − amount;结果展示的 positive 判断用返回的 payoutMultiplier ≥ 1,而共享统计还单独区分 draw。两个口径不能混用。

D02 D03 D04 D05 D06 D08
13

手动模式:从输入到结果的完整链路

控制流、网络传参和视觉反馈是不同步骤。

01输入校验

金额 / 余额 / 胜率 / 倍数

02进入 fetching

调用 mutationBet,产生 identifier

03POST dice/roll

传入 5 个参数,等待响应

04更新结果

倍率、结果、余额与动画

idle --BET--> fetching
  成功:SUCCESS → addBetToContext → setBetState → finishGame
  失败:rollback(identifier) → reject → ERROR → idle

请求参数为 target / condition / identifier / amount / currency。HTTP client 将配置中的 httpUrl 与 dice/roll 拼接,以 JSON POST;会话存在时添加访问 token。这里分析的是封装代码,没有读取或保存实际 token。

客户端读取响应里的 diceRoll,补上 identifier。非 instant 模式会补足约 300ms 的展示等待;不是服务器执行固定耗时 300ms。返回的 amount/payout/currency 用于余额乐观更新,异常使用 identifier 回滚。

结果坐标与倍率来自响应。此请求链里没有用客户端 seed 算真实随机结果,也没有用本地 target/result 再独立开奖。

D09 D18 D19 D20 D28
14

自动模式:不是一个简单的循环

状态机把请求、展示、策略决策和停止意图分开,避免用一个 while 循环承包全部行为。

自动模式启动时记录初始快照,清空累计统计,进入两个并行区域:base 负责一局一局地发请求、显示、结算;nextBet 保存继续或停止的意图。用户点击停止可以先标记 stop,当前已发出的请求仍需按正常返回流程处理。

baseidle / 决定下一局fetchingrevealing回到 idle
nextBetcontinue用户 STOP / 条件停止stop

Dice 自动模式的 revealing 在进入时 finishGame,然后 instant 立即转回 idle,否则等 400ms;高级模式将 finishGame 放在 revealing 的退出处。因此不能把两套状态机当成同一个模板。

每轮决策和停止顺序

  1. 已有结果时更新历史、净累计盈亏、连续胜负;处理剩余局数。
  2. 按顺序评估条件块:局数、连胜连败、利润、亏损和余额等。
  3. 应用金额或游戏状态 action:百分比增减、绝对增减、设置、重置或停止。
  4. 停止优先级:条件块 stop → 局数耗尽 → 下一局金额超过余额 → 潜在止损预检。

净统计是累计 payout − amount,再得出 profit=max(net,0)、loss=max(−net,0)。止盈止损不是把每次赢款或亏款分别相加。默认自动策略是赢后/输后重置;高级模板包含 Martingale、Paroli、D’Alembert 等。

共享 wrapper 有特定条件下的 500ms 重试、最多尝试到计数 10;触发条件比仅 parallelCasinoBet 错误更宽。换币会发出停止自动模式的事件。

D10 D11 D12 D13 D14 D15 D17 D21 D24
15

余额:按 identifier 协调多种异步来源

请求、余额推送与动画结束可能先后不同,事件账本让它们可以对齐。

余额并非只写一个数字。共享账本按 identifier 保存扣减、乐观结果、原始余额同步、WebSocket 更新、游戏结束与回滚事件;展示余额由 raw balance 减去尚未清理的 deduction 派生。

事件含义代码中的作用
INITIAL_DEDUCTION登记本局记录Dice 此处 create 的 amount=0
OPTIMISTIC响应后的本地结果写返回金额与派彩
RAW_SYNC / WS_UPDATE另一来源的真实余额与事件账本一起归并
GAME_FINISHED本局展示/结算流程结束参与记录清理条件
ROLLBACK请求失败或撤回本地记录移除对应 identifier 的影响

例如请求响应先到、WebSocket 后到时,账本能保留本局待对齐的事件;满足 finished 与同步条件后再清理。这个“协调乱序到达”的意图是根据事件结构归纳,实际网络先后顺序和所有边界情况尚未实测。

纠正早期报告:Dice 调用 create({amount:0,currency});不能据此称它在请求发出前就扣除真实下注金额。返回之后才按真实 amount/payout 进行 optimisticBalanceUpdate。
D19 D22 D23
16

公平性计算器:另一条本地计算链

这是验证结果的前端工具,与真实游戏请求链相互独立。

计算器输入来自 URL searchParams,再派生输入元数据、最终结果和拆解步骤。各游戏在配置表中声明参数、字节数量、映射方法和步骤展示。计算器核心代码有 32 个游戏配置分支,不能把这个数字当成匿名可玩游戏数。

01输入

serverSeed / clientSeed / nonce

02HMAC-SHA256

消息 clientSeed:nonce:cursor

03字节 → 浮点

默认每数值用 4 字节

04游戏映射

整数、抽样、倍率或符号

message = `${clientSeed}:${nonce}:${cursor}`
HMAC = crypto.subtle.sign("HMAC", importedKey, messageBytes)
float = b0/256 + b1/256² + b2/256³ + b3/256⁴

serverSeed 经 TextEncoder 编码为 HMAC key;字符串不是先按十六进制解析。默认浮点字节数为 4,每轮 HMAC 提供 32 个可用字节;超过一轮时按 cursor 生成多段 HMAC 并拼接。

有重复映射使用 floor(float×size);无重复抽样从剩余候选数组 splice 移除已选项。卡牌、Mines 和其他游戏按配置使用不同 count/size;Crash 等路径使用 hash/seed 与整数分解,不能把 Dice 公式套到全部游戏。

浏览器使用 WebCrypto 和 Promise.all 完成种子计算。所分析的核心路径未发现 Worker;没有证据说明后台开奖服务使用同一个实现。计算器只能根据给定/已公开的输入复算。

最终结果与解释步骤分别触发计算,可能重复 HMAC 工作。Plinko/Wheel 的赔率展示还会请求 payout 表;“种子到随机路径是本地计算”不等于整页全部离线。该赔率请求现场不传 seed/nonce。

FAIR-01 FAIR-07 FAIR-09 FAIR-10 FAIR-11 FAIR-12 FAIR-38 FAIR-39

HMAC / bytes / float / shuffle 核心 · 输入、调度与游戏映射 · 详见 F 系列证据

17

各游戏如何使用同一组随机材料

下面恢复的是计算器适配算法;只有 Dice 的在线前端控制流程被深读。

游戏/类别随机数到结果实现边界
Dicefloor(float × 10001) ÷ 100,保留两位范围 0–100;与胜率99/chance是两种不同公式 FAIR-14
Roulette / Wheelfloor(float×37);floor(float×segments)Wheel赔率按risk/segments另查表 FAIR-16 FAIR-38
Mines / Keno从25/40个位置不放回抽样;Mines截取minesCountMines坐标 x=index%5+1,y=5−floor(index/5) FAIR-17
Plinko20个0/1序列按rows截断,映射L/R路径risk影响赔率展示,不改变本段随机路径 FAIR-18
Flipfloat > .5 为heads,否则tails等于.5走tails FAIR-19
Limbofloor(float×2²⁴),max(1,2²⁴/(int+1)×.99)32位hash路径并不相同 FAIR-20
Crash / SlideHMAC(hash,seed)前8hex→整数→边际倍率边际分别1%/2%;不代表实时游戏时序已恢复 FAIR-20
Dragon Tower按difficulty,每轮不放回抽安全位置,共9轮解释层单组步骤不等于九轮全展示 FAIR-22
Blackjack / Hilo / Baccarat固定size52映射,序列允许重复Video Poker使用不放回抽样;Baccarat另有补牌规则 FAIR-29 FAIR-30
Video Pokersize52不放回序列,前10分成两组5张原始序列与展示手牌需区分 FAIR-29
Slots / Tome每轮5项,前4按30,第5按41映射roundIndex切片;负值截到0 FAIR-25
Samurai普通18/特殊12浮点;按概率表映射符号游标取决于此前特殊轮数量 FAIR-26 FAIR-27
Darts / Pump / Chicken / Moles专属几何、抽样或难度配置专属得分/派彩helper尚非全部深读 FAIR-23 FAIR-24 FAIR-28
Bars / Cases / Packs / Tarot / Drill浮点进入专属概率表/累计阈值表不都在通用配置中;完整经济逻辑未恢复 FAIR-31
ZooHMAC前三个8hex窗口转整数%20,按权重映射动物只恢复验证器映射,不是在线开奖执行 FAIR-21
18

前端请求层与数据边界

静态代码可以恢复协议形状,但不能替代真实运行证据。

后端接口单独放在附录:160个GraphQL操作及HTTP/WS契约。以下只说明前端怎样消费数据。

路径/机制用途已确定未验证
GraphQL游戏元数据、推荐、收藏等构建里保留 query AST 与变量结构全部操作响应及账户权限
游戏 HTTP clientDice 等游戏操作POST JSON;配置基址 + dice/roll真实下注响应、服务端校验
会话与配置 store登录、站点差异、功能开关组件条件和依赖关系全部开关当前取值与服务端授权
余额账本合并 HTTP、raw sync、WS 更新identifier 与事件清理条件网络乱序、断线与恢复实测
WebCrypto公平性本地复算HMAC、字节和映射公式隐藏 server seed、后端实现

页面初始数据、当前 store 与后端返回不是同一个来源。共享包里包含多个产品分支;分析时必须结合当前配置,不能因某个字符串或路由存在就宣称该功能可用。

19

值得进一步验证的边界

这些位置适合做下一轮运行核验;当前证据只能支持有界的静态判断。

零结果的视觉反馈

Dice 的声音/显示 effect 以 if(result) 触发。result=0 可能跳过该 effect;这是静态候选问题,尚未复现,不能称已确认游戏错误。

D25 D30

多个策略块的状态累计

amount action 逐项累计,但 gameState action 接收同一原始状态。多个修改胜率的块可能不按预想顺次叠加;需对应策略复现。

D16 D29

计算器异步竞态

calculate 的异步结果写回 store;需验证快速改输入时旧计算能否晚到覆盖新值。暂不下运行缺陷结论。

F 系列证据

nonce 未出现在 URL 时保存为空字符串,输入显示可能转换成 0;这能解释此前观察的“显示 0 但计算消息不同”。不是服务端随机机制存在漏洞的证据。

20

REA MCP 做了什么,哪些仍靠源码核对

MCP 的完整扫描不代表所有动态语义都已确定;这里逐项保留限制。

此次实际调用 REA MCP 的 analyze_javascript_application、inspect_analysis_view、trace_javascript_semantics。输入是本地抓取的生产 JS;分析不执行网站业务代码。

全量覆盖更新:774个JS均经独立AST解析,合计1,522,676个AST节点,无解析失败。首批566个沿用相同SHA的REA证据,后补208个拆为28批REA扫描,208/208解析成功。动态语义仍受工具支持和资源预算限制。76份CSS是词法索引,不冒称完整CSS AST。

全部850份JS/CSS逐文件覆盖 · 28批REA证据 · AST与依赖图JSON

分析切片文件与解析覆盖判断
Dice 请求/状态/公式8 文件,10,544 个 AST 节点,0 解析失败文件扫描完整;动态对象/调用语义仍有 unknown
计算器配置/调度3 文件,16,098 个 AST 节点,0 解析失败语义结果触及资源预算,覆盖 partial
纯加密 helper1 文件,1,691 个 AST 节点,0 解析失败扫描完整;静态语义仍保守
外壳/首页/游戏布局3 文件,135,682 个 AST 节点,0 解析失败大组件语义预算受限

以 rollback 作为种子,MCP 找到属性槽,但无法唯一确定其接收者;dice/roll 与 hmacMessage 的语义种子没有形成完整路径。因此本报告的业务链路是“MCP 解析和关系证据 + 人工逐段读源码”的结果,不能包装成自动恢复的完整调用图。

Dice / 计算器 MCP 原始摘要与 trace · 加密 helper MCP · 布局 MCP

查看 MCP Evidence ID
Dice parent: ev_b7237a4ff1c2fa54ca9454b185c2eb7f1faeb695b4a940096e709f57cdfba095
Calculator parent: ev_27a23a2e0ec2a86849d4ee2421f1ab474a6874a0bd1115ca88e93ccd05b2168f
Crypto parent: ev_6bb3772834e04c1db9c1ee3b52889a193d32e67c39b99d25b6ff6020594bed81
Layout parent: ev_32817dcdd0beb8f92b8a62363ea587e0f2aad6ddccdcf2c0d1b5e205c2208ee5
21

逐项前端源码证据

展开可查看原代码、位置和限制;JSON 保留完整核查记录。

D = Dice;FAIR = 公平性计算;L = 布局与数据;UI = 共享交互;SUP = 样式、资产与供应商边界。字符偏移从 0 开始,以解码后的源码字符串计,不是字节偏移。代码片段保持原始压缩变量名;上文用业务名字解释。

D01 页面 node 102 只包装并调用 B_cV99S- 的 Dice 组件;组件挂载时设置游戏配置并初始化共享 general/autobet/listener。

nodes/102.DleFJl8J.mjs · 字符偏移 0 · static_observation

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

import "../chunks/BGNdxI84.mjs";
import "../chunks/xihTtKlq.mjs";
import { t as e } from "../chunks/B_cV99S-.mjs";
function t(t) {
  e(t, {});
}
export { t as component };
D02 Dice 默认 target=50.50、condition=above;由联动公式得到 chance=49.50%、payout=2.0000。amount store 初始为 0。

chunks/B_cV99S-.mjs · 字符偏移 2588 · static_observation

格式化上下文 · 第99行起;原始精确片段保留在证据JSON。打开带行号阅读版

var W = {
    win: ge(H, `/_app/immutable/assets/win.0F07EoV8.mp3`),
    tick: ge(H, `/_app/immutable/assets/tick.DagDZpm1.mp3`),
    rolling: ge(H, `/_app/immutable/assets/rolling.D_aX3p5f.mp3`),
  },
  G = e({
    amount: () => K,
    amountHint: () => dt,
    amountHintEnabled: () => ft,
    amountValidationError: () => ut,
    balance: () => _t,
    chips: () => vt,
    conversion: () => ct,
    currency: () => it,
    disabled: () => q,
    fetching: () => pt,
    hotkeysEnabled: () => mt,
    inPlay: () => lt,
    initialState: () => gt,
    lastBet: () => at,
    modal: () => ht,
    tab: () => ot,
    totalChipsBetAmount: () => yt,
    xstate: () => st,
  }),
D03 前端胜率函数 chance(target,condition)=above?100-target:target;倍率=100/chance*(1-0.01)=99/chance。倍率输入反推 target=above?100-99/multiplier:99/multiplier;反推 target 经两位格式化。

chunks/A1SHOdb7.mjs · 字符偏移 2693 · static_observation

格式化上下文 · 第207行起;原始精确片段保留在证据JSON。打开带行号阅读版

var R = (e, t) => Number(_(t === `above` ? 100 - e : e)),
  z = (e, t) => (t === `above` ? 100 - e : e),
  B = (e, t) => (100 / z(e, t)) * (1 - C),
  V = (e, t) => R((100 * (1 - C)) / e, t),
  H = (e, t) => R(e, t),
  U = (e) => y(String(e), { max: 98, min: T }),
  W = ({ gameState: e, value: t }) => {
    let n = H(t, e?.condition);
    return (e?.condition === `above` ? n >= 2 && n <= 99.99 : n >= 0.01 && n <= 98)
      ? { gameState: { ...e, chance: t, target: n } }
      : { stop: !0, message: `winChanceInvalid` };
  },
  G = {
    switchOverUnder: ({ gameState: e }) => ({
      gameState: {
        condition: e.condition === `above` ? `below` : `above`,
        target: 100 - Number(e.target),
      },
    }),
    increaseWinChanceBy: (e) =>
      W({ ...e, value: Number(e.gameState?.chance) + x(e.value, Number(e.gameState?.chance)) }),
    decreaseWinChanceBy: (e) =>
      W({ ...e, value: Number(e.gameState?.chance) - x(e.value, Number(e.gameState?.chance)) }),
    addToWinChance: (e) => W({ ...e, value: Number(e.gameState?.chance) + e.value }),
    subtractFromWinChance: (e) => W({ ...e, value: Number(e.gameState?.chance) - e.value }),
D04 常量:house edge .01、minimum chance .01、minimum multiplier 1.0102、maximum multiplier 9900;普通 range slider min2/max98。chance 输入 min .01/max98,multiplier 输入 min1.0102/max9900。这些是客户端约束,并非服务端验证实证。

chunks/Bpp_wWJx.mjs · 字符偏移 493 · static_observation

格式化上下文 · 第35行起;原始精确片段保留在证据JSON。打开带行号阅读版

var N = 0.01,
  P = 0.01,
  F = 1.0102,
  I = 9900,
  L = h(`<div class="content svelte-12oz12b"><div class="value svelte-12oz12b"> </div></div>`),
  R = h(`<div class="wrap svelte-12oz12b"></div>`);
function z(e) {
  let t = [0, 25, 50, 75, 100];
  var a = R();
  (f(
    a,
    20,
    () => t,
    (e) => e,
    (e, t) => {
      var a = L();
      let s;
      var l = g(a),
        u = o(l, !0);
      (y(a),
        r(() => {
          ((s = n(a, ``, s, { left: `${t ?? ``}%` })), i(u, t));
        }),
        c(e, a));
    },
D05 格式化使用 Math.round(value*10**precision)/10**precision 再 toFixed;target 常规两位,payout/chance display 四位。

chunks/DtvVV7G6.mjs · 字符偏移 1645 · static_observation

格式化上下文 · 第9行起;原始精确片段保留在证据JSON。打开带行号阅读版

var c = (e) => (e === 1 ? `draw` : e > 1 ? `win` : `lose`),
  l = (e) => new Promise((t) => setTimeout(t, e)),
  u = (e) =>
    e.game?.name
      ? e.game.name
      : e.bet?.__typename === `ThirdPartyBet` && e.bet.thirdPartyGame
        ? e.bet.thirdPartyGame.name
        : e.bet && `game` in e.bet
          ? e.bet.game
          : ``,
  d = (e) => {
    if (
      e?.bet?.__typename === `SportBet` ||
      e?.bet?.__typename === `SportsbookXMultiBet` ||
      !e?.bet ||
      !(`amount` in e.bet)
    )
      return null;
    let {
        id: t,
        iid: n,
        game: r,
        bet: { user: i, amount: a, payoutMultiplier: o, payout: s, currency: l },
      } = e,
      d = a,
D06 target/change 更新 target 后重新计算 payout 与 chance;condition toggle 切换 above/below 并令 target=100-target,以保持胜率。

chunks/B_cV99S-.mjs · 字符偏移 2777 · static_observation

格式化上下文 · 第165行起;原始精确片段保留在证据JSON。打开带行号阅读版

var X = (() => {
    let e = T(J),
      t = (t) => {
        e.set(P(t, 2));
      };
    return {
      ...e,
      format: t,
      reset: () => {
        e.set(J);
      },
      change: ({ value: e, condition: n }) => {
        let r = B(Number(e), n);
        (t(Number(e)), Q.format(), $.format(r));
      },
    };
  })(),
  Z = (() => {
    let e = T(Y);
    return {
      ...e,
      reset: () => {
        e.set(Y);
      },
      toggle: () => {
D07 纯函数 winChance block 计算 target 并按 above 2..99.99、below .01..98 校验;不合范围返回 stop/winChanceInvalid。增加/减少胜率、直接设置、重置、翻转条件被并入允许 action。

chunks/A1SHOdb7.mjs · 字符偏移 2867 · static_observation

格式化上下文 · 第207行起;原始精确片段保留在证据JSON。打开带行号阅读版

var R = (e, t) => Number(_(t === `above` ? 100 - e : e)),
  z = (e, t) => (t === `above` ? 100 - e : e),
  B = (e, t) => (100 / z(e, t)) * (1 - C),
  V = (e, t) => R((100 * (1 - C)) / e, t),
  H = (e, t) => R(e, t),
  U = (e) => y(String(e), { max: 98, min: T }),
  W = ({ gameState: e, value: t }) => {
    let n = H(t, e?.condition);
    return (e?.condition === `above` ? n >= 2 && n <= 99.99 : n >= 0.01 && n <= 98)
      ? { gameState: { ...e, chance: t, target: n } }
      : { stop: !0, message: `winChanceInvalid` };
  },
  G = {
    switchOverUnder: ({ gameState: e }) => ({
      gameState: {
        condition: e.condition === `above` ? `below` : `above`,
        target: 100 - Number(e.target),
      },
    }),
    increaseWinChanceBy: (e) =>
      W({ ...e, value: Number(e.gameState?.chance) + x(e.value, Number(e.gameState?.chance)) }),
    decreaseWinChanceBy: (e) =>
      W({ ...e, value: Number(e.gameState?.chance) - x(e.value, Number(e.gameState?.chance)) }),
    addToWinChance: (e) => W({ ...e, value: Number(e.gameState?.chance) + e.value }),
    subtractFromWinChance: (e) => W({ ...e, value: Number(e.gameState?.chance) - e.value }),
D08 利润预览=格式化(amount*multiplier-amount)。请求成功后的本地 win flag 是 payoutMultiplier>=1;共享统计 classify 则 multiplier=1 为 draw、>1 win、<1 lose,不能把两者无条件当相同口径。

chunks/B_cV99S-.mjs · 字符偏移 5962 · static_observation

格式化上下文 · 第394行起;原始精确片段保留在证据JSON。打开带行号阅读版

function kt(e, t) {
  w(t, !0);
  let n = () => C(K, `$amount`, o),
    r = () => C(X, `$targetStore`, o),
    i = () => C(Z, `$condition`, o),
    a = () => C(it, `$currency`, o),
    [o, s] = c(),
    l = m(() => k(Number(n()) * z(Number(r()), i()) - Number(n())));
  {
    let t = m(() => ne === !1);
    je(e, {
      get currency() {
        return a();
      },
      get value() {
        return S(l);
      },
      get hideConversion() {
        return S(t);
      },
    });
  }
  (b(), s());
}
var At = _(`<!> <!> <!> <!>`, 1),
D09 manual 状态 idle --BET-->fetching;invoke mutationBet,成功 raise SUCCESS;Dice 覆盖 SUCCESS 执行 addBetToContext、setBetState、finishGame。失败 ERROR 返回 idle。

chunks/DJEMTsfs.mjs · 字符偏移 70 · static_observation

格式化上下文 · 第3行起;原始精确片段保留在证据JSON。打开带行号阅读版

function n(n) {
  let r = {
    initial: `idle`,
    id: `betTab`,
    states: {
      idle: {
        id: `betTab.idle`,
        on: {
          BET: { target: `fetching` },
          TO_AUTOBET: { target: `#autobetTab` },
          TO_ADVANCED: { target: `#advancedTab` },
        },
      },
      fetching: {
        invoke: {
          id: `mutationBet`,
          src: `mutationBet`,
          onDone: { actions: t((e, t) => ({ type: `SUCCESS`, bet: t.data })) },
          onError: { actions: t(`ERROR`) },
        },
        on: {
          SUCCESS: { target: `idle`, actions: [`setInitialBettingState`] },
          ERROR: { target: `idle` },
        },
      },
D10 auto start 记录初始状态,清空累计统计/snapshot,进入并行 base 与 nextBet;base idle 更新 history+totals并执行 decideOnNextBet;fetching 成功进入 revealing;失败回 autobet idle。nextBet 独立接收用户 STOP/TOGGLE/TO_BET,将 continue 标记 stop。

chunks/As2sFYtL.mjs · 字符偏移 267 · static_observation

格式化上下文 · 第12行起;原始精确片段保留在证据JSON。打开带行号阅读版

function u(t) {
  let r = {
    initial: `idle`,
    id: `autobetTab`,
    entry: [`initAutobetDefaultStrategies`],
    states: {
      idle: {
        id: `autobetTab.idle`,
        on: {
          TOGGLE_AUTOBETTING: { target: `betting`, actions: [`setInitialBettingState`] },
          TO_BET: { target: `#betTab` },
          TO_ADVANCED: { target: `#advancedTab` },
        },
      },
      betting: {
        entry: [o, `snapshotAutobetInfo`, l],
        exit: [c],
        type: `parallel`,
        states: {
          base: {
            initial: `idle`,
            states: {
              idle: {
                type: `final`,
                entry: [s, a],
D11 Dice auto revealing entry 调用 finishGame,然后 instantResult 为真立即 TO_IDLE,否则400ms后 TO_IDLE;advanced revealing 的 finishGame 放在 exit。成功写结果,余额 settle 时机因此在两个模式略有差异。

chunks/B_cV99S-.mjs · 字符偏移 7536 · static_observation

格式化上下文 · 第549行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Ft = Ze({
    initial: `idle`,
    id: `advancedTab`,
    states: {
      idle: {},
      betting: {
        states: {
          base: {
            states: {
              idle: {},
              fetching: { on: { SUCCESS: { actions: [`addBetToContext`, `setBetState`] } } },
              revealing: {
                exit: `finishGame`,
                on: { TO_IDLE: `idle` },
                invoke: {
                  id: `revealingTimeout`,
                  src: () => (e) => {
                    f(U) === !0
                      ? e(`TO_IDLE`)
                      : setTimeout(() => {
                          e(`TO_IDLE`);
                        }, 400);
                  },
                },
              },
D12 auto decide 只在已有 bet/history 时递减 gamesLeft(0不递减)。抓取余额与初始 snapshot,评估 ordered blocks、应用 handler,再检查 stopping。原 gamesLeft=1 时返回 limitReached,意味着最后一局结算后阻止下一局。

chunks/DBgOd0is.mjs · 字符偏移 1052 · static_observation

格式化上下文 · 第31行起;原始精确片段保留在证据JSON。打开带行号阅读版

function k({ getGameState: t, getStakeAmount: n, autobet: r, general: i, handler: a }, o) {
  return (s) =>
    new Promise((c, l) => {
      let { bet: u } = s,
        f = s.betHistoryTotal ?? w;
      if (u && s.betHistory?.length) {
        let s = () => h(`autobetTab.betting.nextBet.stop`, e(i.xstate));
        if (s() === !1) {
          let c = n ? n() : Number(e(i.amount)),
            p = o ? e(i.totalChipsBetAmount) : c,
            m = Number(e(r.gamesLeft));
          m !== 0 && r.gamesLeft.set(m - 1);
          let h = e(d)[u.currency].available,
            g = typeof t == `function` ? t() : {},
            _ = e(i.initialState);
          o && _.chips && (_.amount = v(_.chips));
          let y = ne({
            blocks: e(r.blocks),
            betHistoryTotal: f,
            balance: h,
            gameState: g,
            amount: p,
            initialState: _,
            actions: r?.allowedActions,
          });
D13 停止优先级:block stop及message → gamesLeft===1 → next amount>balance → potentialStopLoss。潜在止损预检是下一局金额+当前累计loss>=defaultStopOnLoss阈值。

chunks/DYosYWTC.mjs · 字符偏移 923 · static_observation

格式化上下文 · 第23行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ title: { id: `Ifq4hV` }, body: { id: `dDj4u0` }, icon: y, type: `warn` }),
  k = (e, t) => {
    let n = e - t;
    return Math.abs((n / e) * 100);
  },
  A = ({ blockResults: e, balance: t, amount: n, gamesLeft: r, potentialStopLoss: i }) => {
    if (e?.stop) return e.message ?? `conditionalBlockCalledStop`;
    if (r === 1) return `limitReached`;
    if (n > t) return `insufficientBalance`;
    if (i) return `potentialStopLossReached`;
  },
  j = ({ blocks: e, id: t, value: n, blockDefault: r, target: i }) =>
    e.some((e) => e.id === t)
      ? e.map((e) => {
          let r = structuredClone(e);
          return (e.id === t && (r[i].value = n), r);
        })
      : [...e, { ...r, [i]: { ...r[i], value: n } }],
  M = (e) => {
    if (!Array.isArray(e)) return [];
    let t = (e) => typeof e == `object` && !!e,
      n = (e) => typeof e.type == `string` && e.type !== ``,
      r = new Set();
    return e.reduce((e, i) => {
      if (!t(i) || !t(i.on) || !t(i.do) || !n(i.on) || !n(i.do)) return e;
D14 block 条件:every 按 bets/wins/losses累计数取模且 win/lose须匹配当前 streakType;everyStreakOf/firstStreakOf/greater/lower 读连胜连败长度;profit/loss/balance 支持比较。amount actions 可增加/减少百分比、绝对加减、设置、重置、stop,且新amount须0<=amount<=balance。

chunks/DF2YAqRD.mjs · 字符偏移 269 · static_observation

格式化上下文 · 第9行起;原始精确片段保留在证据JSON。打开带行号阅读版

var s = ({ history: e, betType: t, value: n }) => {
    switch (t) {
      case `bet`:
        return e.bets % n === 0;
      case `win`:
        return t === e.streakType && e.wins % n === 0;
      case `lose`:
        return t === e.streakType && e.losses % n === 0;
      default:
        return !1;
    }
  },
  c = (e, t, n) => {
    switch (e) {
      case `every`:
        return t % n === 0;
      case `greater than`:
        return t > n;
      case `greater than or equal to`:
        return t >= n;
      case `lower than`:
        return t < n;
      case `lower than or equal to`:
        return t <= n;
      case `first`:
D15 累计统计按 payout-amount 累加 balanceDiff;profit=max(balanceDiff,0),loss=max(-balanceDiff,0),所以止盈止损依据净累计利润/亏损,不是各局赢款/损失简单求和。draw 会变为独立 streakType。

chunks/DF2YAqRD.mjs · 字符偏移 2704 · static_observation

格式化上下文 · 第9行起;原始精确片段保留在证据JSON。打开带行号阅读版

var s = ({ history: e, betType: t, value: n }) => {
    switch (t) {
      case `bet`:
        return e.bets % n === 0;
      case `win`:
        return t === e.streakType && e.wins % n === 0;
      case `lose`:
        return t === e.streakType && e.losses % n === 0;
      default:
        return !1;
    }
  },
  c = (e, t, n) => {
    switch (e) {
      case `every`:
        return t % n === 0;
      case `greater than`:
        return t > n;
      case `greater than or equal to`:
        return t >= n;
      case `lower than`:
        return t < n;
      case `lower than or equal to`:
        return t <= n;
      case `first`:
D16 blocks 逐项 reduce,上一项 stop 后余项只标fail;amount 传入上一项的 e.amount,gameState 参数却始终传入原始 i,未取累计 e.gameState。这表示同轮多个 gameState action 可能以同一轮原始状态为基准;应复现核验后再判定是否缺陷。

chunks/DF2YAqRD.mjs · 字符偏移 3087 · static_observation_and_bounded_inference

格式化上下文 · 第9行起;原始精确片段保留在证据JSON。打开带行号阅读版

var s = ({ history: e, betType: t, value: n }) => {
    switch (t) {
      case `bet`:
        return e.bets % n === 0;
      case `win`:
        return t === e.streakType && e.wins % n === 0;
      case `lose`:
        return t === e.streakType && e.losses % n === 0;
      default:
        return !1;
    }
  },
  c = (e, t, n) => {
    switch (e) {
      case `every`:
        return t % n === 0;
      case `greater than`:
        return t > n;
      case `greater than or equal to`:
        return t >= n;
      case `lower than`:
        return t < n;
      case `lower than or equal to`:
        return t <= n;
      case `first`:
D17 默认自动初始策略只装 reset-on-win/reset-on-loss;高级模式默认 Martingale:输后金额+100%、赢后重置。另内置 Delayed Martingale/Paroli/D Alembert,并支持保存、加载、条件块顺序移动与清理无效/重复ID。

chunks/DBgOd0is.mjs · 字符偏移 11115 · static_observation

格式化上下文 · 第444行起;原始精确片段保留在证据JSON。打开带行号阅读版

function ae(n) {
  let r = $(0),
    i = n?.actionOptions || T,
    a = { ...n?.validators },
    o = (() => {
      let n = t(!1),
        r = $([]),
        a = $(null);
      r.set([]);
      let s = (e) => r.update((t) => t.filter((t) => t.id !== e));
      return {
        ...r,
        enabled: n,
        add: (e) => r.update((t) => [...t, e]),
        reset: () => r.set([]),
        allowedActions: i,
        editIndex: a,
        remove: s,
        move: ({ position: t, up: n }) => {
          let i = e(r),
            a = n ? t - 1 : t + 1;
          (i[a] && ([i[a], i[t]] = [i[t], i[a]]), r.set([...i]));
        },
        enable: () => {
          (r.update((e) => _({ blocks: e, block: Y }).filter((e) => e.id !== Q.id)),
D18 Dice mutation 从amount/currency/condition/target stores取值,create({amount:0,currency})产生identifier,再POST dice/roll。payload为 target、condition、identifier、amount、currency。成功返回diceRoll并补identifier;非instant等待请求开始至至少300ms。结果来自响应,前端此链未计算随机结果。

chunks/B_cV99S-.mjs · 字符偏移 9963 · static_observation

格式化上下文 · 第549行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Ft = Ze({
    initial: `idle`,
    id: `advancedTab`,
    states: {
      idle: {},
      betting: {
        states: {
          base: {
            states: {
              idle: {},
              fetching: { on: { SUCCESS: { actions: [`addBetToContext`, `setBetState`] } } },
              revealing: {
                exit: `finishGame`,
                on: { TO_IDLE: `idle` },
                invoke: {
                  id: `revealingTimeout`,
                  src: () => (e) => {
                    f(U) === !0
                      ? e(`TO_IDLE`)
                      : setTimeout(() => {
                          e(`TO_IDLE`);
                        }, 400);
                  },
                },
              },
D19 成功用返回amount/payout/currency做 optimisticBalanceUpdate;异常使用identifier rollback再reject。create 的amount为0,因此不能称Dice此处请求前就按实际下注金额扣款。finishGame稍后补GAME_FINISHED事件。

chunks/B_cV99S-.mjs · 字符偏移 10329 · static_observation

格式化上下文 · 第549行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Ft = Ze({
    initial: `idle`,
    id: `advancedTab`,
    states: {
      idle: {},
      betting: {
        states: {
          base: {
            states: {
              idle: {},
              fetching: { on: { SUCCESS: { actions: [`addBetToContext`, `setBetState`] } } },
              revealing: {
                exit: `finishGame`,
                on: { TO_IDLE: `idle` },
                invoke: {
                  id: `revealingTimeout`,
                  src: () => (e) => {
                    f(U) === !0
                      ? e(`TO_IDLE`)
                      : setTimeout(() => {
                          e(`TO_IDLE`);
                        }, 400);
                  },
                },
              },
D20 HTTP client 把 httpUrl 与 dice/roll 拼接,POST JSON,Content-Type application/json;getSession非空时加x-access-token;响应经过状态检查,再解析JSON,errors数组抛错。parallelCasinoBet单独reject,其他错误推送共享errorExchange。这里没有请求重放/下注实测。

chunks/DYosYWTC.mjs · 字符偏移 3952 · static_observation

格式化上下文 · 第23行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ title: { id: `Ifq4hV` }, body: { id: `dDj4u0` }, icon: y, type: `warn` }),
  k = (e, t) => {
    let n = e - t;
    return Math.abs((n / e) * 100);
  },
  A = ({ blockResults: e, balance: t, amount: n, gamesLeft: r, potentialStopLoss: i }) => {
    if (e?.stop) return e.message ?? `conditionalBlockCalledStop`;
    if (r === 1) return `limitReached`;
    if (n > t) return `insufficientBalance`;
    if (i) return `potentialStopLossReached`;
  },
  j = ({ blocks: e, id: t, value: n, blockDefault: r, target: i }) =>
    e.some((e) => e.id === t)
      ? e.map((e) => {
          let r = structuredClone(e);
          return (e.id === t && (r[i].value = n), r);
        })
      : [...e, { ...r, [i]: { ...r[i], value: n } }],
  M = (e) => {
    if (!Array.isArray(e)) return [];
    let t = (e) => typeof e == `object` && !!e,
      n = (e) => typeof e.type == `string` && e.type !== ``,
      r = new Set();
    return e.reduce((e, i) => {
      if (!t(i) || !t(i.on) || !t(i.do) || !n(i.on) || !n(i.do)) return e;
D21 共享 service wrapper 在parallelCasinoBet或触发event.type为done.invoke.decideOnNextBet时,失败后500ms重试;n从1开始,到10不再重试。此源码条件比“只重试parallel错误”更宽,不宜写成仅并行下注错误重试。

chunks/DBgOd0is.mjs · 字符偏移 2140 · static_observation

格式化上下文 · 第71行起;原始精确片段保留在证据JSON。打开带行号阅读版

function A(e) {
  let { moduleName: t, services: r, general: i } = e,
    a = t === n.baccarat || t === n.roulette || t === n.zoo,
    o = (t, n, r) => k(e, a)(t, n, r),
    s = (e, t) => (`requestState` in r && r.requestState ? r.requestState(t) : Promise.resolve()),
    c = (e, t, n = 1) => {
      let r = e(t);
      return Promise.resolve(r).catch(async (i) =>
        n >= 10
          ? r
          : i?.errorType === `parallelCasinoBet` || t.type === `done.invoke.decideOnNextBet`
            ? (await new Promise((e) => setTimeout(e, 500)), c(e, t, n + 1))
            : r,
      );
    };
  return {
    requestState: s,
    mutationBet: (e, t) =>
      `mutationBet` in r && r.mutationBet
        ? D(i)
          ? Promise.reject({ errorType: `currencyRatesUnavailable` })
          : c(r.mutationBet, t)
        : Promise.resolve(),
    mutationAutobet: (e, t) =>
      `mutationAutobet` in r && r.mutationAutobet
D22 余额 ledger 按 identifier 管INITIAL_DEDUCTION/OPTIMISTIC/RAW_SYNC/WS_UPDATE/GAME_FINISHED/ROLLBACK;ROLLBACK使记录清除。结束+WS_UPDATE,或结束+optimistic+后续raw sync等条件亦清除。展示余额由raw balance减未清ledger deduction派生,非直接覆盖单一amount。

chunks/DruF6Kad.mjs · 字符偏移 1052 · static_observation

格式化上下文 · 第41行起;原始精确片段保留在证据JSON。打开带行号阅读版

function A(e) {
  let t = e.map((e) => e.type),
    n = t.includes(`ROLLBACK`),
    r =
      t.includes(`INITIAL_DEDUCTION`) &&
      t.includes(`WS_BALANCE_UPDATE`) &&
      t.includes(`GAME_FINISHED`),
    i =
      t.includes(`INITIAL_DEDUCTION`) &&
      t.includes(`OPTIMISTIC_BALANCE_UPDATE`) &&
      t.includes(`RAW_BALANCE_SYNCED`) &&
      t.includes(`GAME_FINISHED`) &&
      D(e, `OPTIMISTIC_BALANCE_UPDATE`, `RAW_BALANCE_SYNCED`),
    a =
      t.includes(`INITIAL_DEDUCTION`) &&
      t.includes(`GAME_FINISHED`) &&
      t.includes(`WS_BALANCE_DISCONNECTED`) &&
      t.includes(`WS_BALANCE_RECONNECTED`) &&
      t.includes(`RAW_BALANCE_SYNCED`);
  return n || r || i || a;
}
var j = (() => {
    function t({ identifier: e, betAmount: t, betPayout: n, currency: r }) {
      j.add({
        type: `OPTIMISTIC_BALANCE_UPDATE`,
D23 create生成identifier并登记INITIAL_DEDUCTION;rollback登记ROLLBACK;finishGame登记GAME_FINISHED。以这些事件协调请求与WebSocket/拉取原始余额的不同先后顺序。

chunks/DruF6Kad.mjs · 字符偏移 3094 · static_observation

格式化上下文 · 第62行起;原始精确片段保留在证据JSON。打开带行号阅读版

var j = (() => {
    function t({ identifier: e, betAmount: t, betPayout: n, currency: r }) {
      j.add({
        type: `OPTIMISTIC_BALANCE_UPDATE`,
        identifier: e,
        betAmount: t ?? 0,
        betPayout: n ?? 0,
        currency: r,
        balanceType: `available`,
      });
    }
    let r = n(``),
      i = n(null),
      a = n({}),
      o = (t) => {
        a.update((n) => {
          if (t.identifier in n)
            ((n[t.identifier] = k(t, n[t.identifier])),
              A(n[t.identifier]) && (n = S(n, t.identifier)));
          else if (t.type === `INITIAL_DEDUCTION`) {
            let r = e(i)?.type !== `connected`;
            n[t.identifier] = r
              ? [{ type: `WS_BALANCE_DISCONNECTED`, identifier: t.identifier }, t]
              : [t];
          }
D24 变更交易币触发STOP_AUTOBETTING;仅idle同步游戏currency。法币模式 inPlay且auto/advanced,conversion变化>10%或新rate===9时停止并显示warn。rate===9的来源/语义尚未解释。

chunks/DYosYWTC.mjs · 字符偏移 1996 · static_observation

格式化上下文 · 第23行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ title: { id: `Ifq4hV` }, body: { id: `dDj4u0` }, icon: y, type: `warn` }),
  k = (e, t) => {
    let n = e - t;
    return Math.abs((n / e) * 100);
  },
  A = ({ blockResults: e, balance: t, amount: n, gamesLeft: r, potentialStopLoss: i }) => {
    if (e?.stop) return e.message ?? `conditionalBlockCalledStop`;
    if (r === 1) return `limitReached`;
    if (n > t) return `insufficientBalance`;
    if (i) return `potentialStopLossReached`;
  },
  j = ({ blocks: e, id: t, value: n, blockDefault: r, target: i }) =>
    e.some((e) => e.id === t)
      ? e.map((e) => {
          let r = structuredClone(e);
          return (e.id === t && (r[i].value = n), r);
        })
      : [...e, { ...r, [i]: { ...r[i], value: n } }],
  M = (e) => {
    if (!Array.isArray(e)) return [];
    let t = (e) => typeof e == `object` && !!e,
      n = (e) => typeof e.type == `string` && e.type !== ``,
      r = new Set();
    return e.reduce((e, i) => {
      if (!t(i) || !t(i.on) || !t(i.do) || !n(i.on) || !n(i.do)) return e;
D25 UI依据xstate切 manual/automated/advanced;手动hotkey space多一层valid校验,q切condition,w/e以整数2..98调target且edgeStop不环绕。结果pastBets=[new,...old.slice(0,25)]最多26条;结果为0不会触发 if(s())的显示/声音 effect。

chunks/B_cV99S-.mjs · 字符偏移 11724 · static_observation

格式化上下文 · 第808行起;原始精确片段保留在证据JSON。打开带行号阅读版

var On = { min: 2, max: 98, step: 1 },
  kn = Me({ general: G, send: wn.send }),
  An = {
    ...kn,
    space: {
      ...kn.space,
      action: () => {
        f(Tt) && kn.space?.action();
      },
    },
    q: {
      action: () => {
        f(q) === !1 && Z.toggle();
      },
      description: V.toggleCondition,
    },
    w: {
      action: () => {
        f(q) === !1 &&
          Dn({
            goBack: !0,
            edgeStop: !0,
            value: Math.ceil(Number(f(X))),
            setter: (e) => X.change({ value: String(e), condition: f(Z) }),
            optionsInfo: On,
D26 general store使idle之外disabled/inPlay,amount校验min0/balance;initial snapshot setter包装{gameState,amount,chips},便于策略resetAmount/resetWinChance。amount的double/max取可用余额,支持halve。

chunks/ri_ajtQq.mjs · 字符偏移 2614 · static_observation

格式化上下文 · 第41行起;原始精确片段保留在证据JSON。打开带行号阅读版

function O({ initialChips: i = {}, gameName: c }) {
  let l = n(null),
    S = n(``),
    C = n(e(f)),
    w = n(`hidden`),
    E = (e) => !(y(`betTab.idle`, e) || y(`autobetTab.idle`, e) || y(`advancedTab.idle`, e)),
    O = t(S, (e) => E(e)),
    k = t(
      S,
      (e) => y(`betTab.fetching`, e) || y(`autobetTab.fetching`, e) || y(`advancedTab.fetching`, e),
    ),
    A = (() => {
      let t = n(p(0));
      return {
        ...t,
        change: ({ amount: e }) => {
          t.set(p(e));
        },
        halve: () => {
          t.update((t) => p(h({ amount: Number(t), currency: e(C) }), e(C)));
        },
        double: () => {
          let n = e(C),
            r = e(g)[n];
          t.update((e) => p(m({ amount: Number(e), balance: r.available, currency: n }), n));
D27 visual result position按result百分比translate;animations开关影响slide/scale/result 300/500/100ms。instantResult与animations是两个独立settings toggle,不能合并成一个快速模式。

chunks/Bpp_wWJx.mjs · 字符偏移 2192 · static_observation

格式化上下文 · 第123行起;原始精确片段保留在证据JSON。打开带行号阅读版

function X(l, u) {
  S(u, !0);
  let f = () => x(J, `$animationsEnabled`, p),
    [p, m] = a(),
    h = d(() => (f() ? 300 : 0)),
    v = d(() => (f() ? 500 : 0)),
    C = d(() => (f() ? 100 : 0));
  var w = Y();
  let T;
  var E = g(w);
  let D, O;
  var k = g(E),
    j = s(k, 2);
  let M;
  var N = o(j, !0);
  (y(E),
    y(w),
    r(
      (r) => {
        (e(w, `data-testid`, `dice-${u.result}`),
          (T = n(w, ``, T, {
            "--dice-slide-transition": `${b(h) ?? ``}ms`,
            transform: `translate(${u.result ?? ``}%, 0)`,
          })),
          (D = t(E, 1, `hide-show ${u.status ?? ``}`, `svelte-1w3idcq`, D, {
D28 结果state.result与payoutMultiplier直接由bet响应写入stores,>=1控制positive状态。胜负判定没有对客户端target与result重新比较,依赖服务端倍率。

chunks/B_cV99S-.mjs · 字符偏移 9859 · static_observation

格式化上下文 · 第549行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Ft = Ze({
    initial: `idle`,
    id: `advancedTab`,
    states: {
      idle: {},
      betting: {
        states: {
          base: {
            states: {
              idle: {},
              fetching: { on: { SUCCESS: { actions: [`addBetToContext`, `setBetState`] } } },
              revealing: {
                exit: `finishGame`,
                on: { TO_IDLE: `idle` },
                invoke: {
                  id: `revealingTimeout`,
                  src: () => (e) => {
                    f(U) === !0
                      ? e(`TO_IDLE`)
                      : setTimeout(() => {
                          e(`TO_IDLE`);
                        }, 400);
                  },
                },
              },
D29 conditional actions 对amount累计,但 Dice handler 要求chance,target,condition三者非undefined才应用gameState,并将chance两位、target四位格式化再写store。

chunks/B_cV99S-.mjs · 字符偏移 10763 · static_observation

格式化上下文 · 第549行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Ft = Ze({
    initial: `idle`,
    id: `advancedTab`,
    states: {
      idle: {},
      betting: {
        states: {
          base: {
            states: {
              idle: {},
              fetching: { on: { SUCCESS: { actions: [`addBetToContext`, `setBetState`] } } },
              revealing: {
                exit: `finishGame`,
                on: { TO_IDLE: `idle` },
                invoke: {
                  id: `revealingTimeout`,
                  src: () => (e) => {
                    f(U) === !0
                      ? e(`TO_IDLE`)
                      : setTimeout(() => {
                          e(`TO_IDLE`);
                        }, 400);
                  },
                },
              },
D30 结果UI收到非0 result后rolling音,300ms后positive/negative并可播放win,3s后隐藏;组件销毁清timeouts。这是UI反馈定时,不等同server下注执行时长。

chunks/B_cV99S-.mjs · 字符偏移 4314 · static_observation

格式化上下文 · 第251行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Ot(e, t) {
  w(t, !0);
  let s = () => C(xt, `$result`, D),
    f = () => C(bt, `$win`, D),
    m = () => C(ie, `$stacked`, D),
    h = () => C(St, `$pastBets`, D),
    g = () => C(X, `$targetStore`, D),
    _ = () => C(q, `$disabled`, D),
    v = () => C(Z, `$condition`, D),
    T = () => C(wt, `$payoutErrorChance`, D),
    te = () => C(Q, `$payout`, D),
    ne = () => C(Ct, `$chanceErrorMessage`, D),
    E = () => C($, `$chance`, D),
    [D, re] = c(),
    ie = he(),
    O = n(o({ status: `neutral`, isHidden: !0 })),
    k,
    A;
  (i(() => {
    if (s()) {
      let e = f();
      (clearTimeout(k),
        clearTimeout(A),
        W.rolling.play(),
        p(O, { isHidden: !1, status: `neutral` }, !0),
FAIR-01 URL 就是输入状态:Mn 从 searchParams 构造 inputValues;Fn 从 page 派生 inputValues 和 inputsMeta。字段没有独立输入草稿 store;非空 URL 字符串直接进入计算函数。

chunks/D04PJvcv.mjs · 字符偏移 38720 · static-observation

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,
FAIR-02 输入每次写 URL:数字和文本 oninput 调 h 写 URL,保留现有 searchParams 并覆盖当前字段,以 replaceState 和 keepFocus 更新路径。局部看不到 debounce。

chunks/D04PJvcv.mjs · 字符偏移 26553 · static-observation

格式化上下文 · 第991行起;原始精确片段保留在证据JSON。打开带行号阅读版

function kt(e, t) {
  D(t, !0);
  let n = () => T(M, `$page`, d),
    i = () => T(N, `$i18n`, d),
    [d, f] = s(),
    m = p(() => n().url.searchParams.get(t.key) || ``),
    h = async (e) => {
      let r = n()?.url?.searchParams?.entries(),
        i = r == null ? {} : B([...r]);
      ee(`${n().url.pathname}?${new URLSearchParams({ ...i, [t.key]: e })}`, {
        replaceState: !0,
        keepFocus: !0,
      });
    },
    g = { variant: `neutral` };
  var _ = Ot(),
    v = x(_),
    b = (e) => {
      {
        let n = (e) => {
            F(e, {
              type: `body`,
              tag: `span`,
              size: `sm`,
              strong: !0,
FAIR-03 数字空串显示 0:number 控件仅在显示层把空串替换成字符串 0;URL 解析仍保留 nonce 空串。省略 nonce 时 HMAC message 是 clientSeed::0,不等于 clientSeed:0:0。

chunks/D04PJvcv.mjs · 字符偏移 27395 · static-observation

格式化上下文 · 第991行起;原始精确片段保留在证据JSON。打开带行号阅读版

function kt(e, t) {
  D(t, !0);
  let n = () => T(M, `$page`, d),
    i = () => T(N, `$i18n`, d),
    [d, f] = s(),
    m = p(() => n().url.searchParams.get(t.key) || ``),
    h = async (e) => {
      let r = n()?.url?.searchParams?.entries(),
        i = r == null ? {} : B([...r]);
      ee(`${n().url.pathname}?${new URLSearchParams({ ...i, [t.key]: e })}`, {
        replaceState: !0,
        keepFocus: !0,
      });
    },
    g = { variant: `neutral` };
  var _ = Ot(),
    v = x(_),
    b = (e) => {
      {
        let n = (e) => {
            F(e, {
              type: `body`,
              tag: `span`,
              size: `sm`,
              strong: !0,
FAIR-04 增减按钮边界:减按钮 Number(value)<1 时写 0,否则减 1;加按钮直接加 1。该按钮逻辑不等于手输验证;手输负数不在这一层被截断。

chunks/D04PJvcv.mjs · 字符偏移 27112 · static-observation

格式化上下文 · 第991行起;原始精确片段保留在证据JSON。打开带行号阅读版

function kt(e, t) {
  D(t, !0);
  let n = () => T(M, `$page`, d),
    i = () => T(N, `$i18n`, d),
    [d, f] = s(),
    m = p(() => n().url.searchParams.get(t.key) || ``),
    h = async (e) => {
      let r = n()?.url?.searchParams?.entries(),
        i = r == null ? {} : B([...r]);
      ee(`${n().url.pathname}?${new URLSearchParams({ ...i, [t.key]: e })}`, {
        replaceState: !0,
        keepFocus: !0,
      });
    },
    g = { variant: `neutral` };
  var _ = Ot(),
    v = x(_),
    b = (e) => {
      {
        let n = (e) => {
            F(e, {
              type: `body`,
              tag: `span`,
              size: `sm`,
              strong: !0,
FAIR-05 游戏字段由配置驱动:inputsMeta 在配置中定义 type input/select 和 props key/options/label;At 依类型渲染 kt/Et。游戏不是一组硬编码独立表单。

chunks/D04PJvcv.mjs · 字符偏移 27986 · static-observation

格式化上下文 · 第1116行起;原始精确片段保留在证据JSON。打开带行号阅读版

function At(t, n) {
  D(n, !0);
  let r = () => T(l, `$inputsMeta`, i),
    [i, o] = s(),
    { inputsMeta: l } = St();
  var d = e(),
    f = c(d);
  (m(
    f,
    1,
    r,
    (e) => e.props.key,
    (t, n) => {
      var r = e(),
        i = c(r),
        o = (e) => {
          kt(
            e,
            k(() => w(n).props),
          );
        },
        s = (e) => {
          Et(
            e,
            k(() => w(n).props),
FAIR-06 32 个游戏适配器:An 是计算函数路由表;Nn 以输入 game 选择 adapter,返回值附 game 标记。未知 game 返回 null;Pn 对未知配置返回空数组。

chunks/D04PJvcv.mjs · 字符偏移 38125 · static-observation

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,
FAIR-07 结果和解释步骤分别计算:finalResult.calculate await Nn,stepsMeta.calculate await Pn;Pn 按 config.steps 并行 Promise.all。说明表与结果不是同一个计算结果拆分,存在重复 HMAC 工作。

chunks/D04PJvcv.mjs · 字符偏移 39819 · static-observation

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,
FAIR-08 没有捕获路径中的 Worker:核对核心 nVEredkt、D04PJvcv、BH2ZjAyW 和页面文件,没有 Worker/postMessage 调度;核心使用浏览器 crypto.subtle,异步 Promise.all 聚合 HMAC。不能据此断言站点所有模块都没有 Worker。

chunks/nVEredkt.mjs · 字符偏移 421 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);

只覆盖上述核心文件,不覆盖整个站点;实际线程由浏览器 WebCrypto 实现决定。

FAIR-09 HMAC 原文编码:A 用 TextEncoder 将 serverSeed 和 hmacMessage 编码为 UTF-8;importKey raw HMAC SHA-256,sign HMAC。serverSeed 不先作为 hex 解码;64 个 0 的 seed 是 64 个 ASCII 零字符。

chunks/nVEredkt.mjs · 字符偏移 4099 · static-observation

格式化上下文 · 第171行起;原始精确片段保留在证据JSON。打开带行号阅读版

async function A({ serverSeed: e, hmacMessage: t }) {
  let n = new TextEncoder(),
    r = n.encode(e),
    i = n.encode(t),
    a = await globalThis.crypto.subtle.importKey(`raw`, r, { name: `HMAC`, hash: `SHA-256` }, !0, [
      `sign`,
      `verify`,
    ]),
    s = await globalThis.crypto.subtle.sign(`HMAC`, a, i);
  return o.Buffer.from(new Uint8Array(s));
}
export {
  h as _,
  w as a,
  E as c,
  O as d,
  D as f,
  m as g,
  T as h,
  d as i,
  A as l,
  x as m,
  f as n,
  g as o,
  y as p,
FAIR-10 默认 4 字节浮点:s 为常量 Set(true/on/1/yes).has(false)?6:4,因此捕获构建实际取 4;每轮可用字节 floor(32/4)*4=32。6 字节代码存在,但此构建常量关闭。

chunks/nVEredkt.mjs · 字符偏移 187 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-11 HMAC 分轮:l 按 ceil(byteCount/32) 生成 clientSeed:nonce:roundIndex 消息,roundIndex 从 0 开始;d 并行对各消息求 HMAC。u 取每轮可用前 32 字节,flatten 后截断到请求 byteCount。

chunks/nVEredkt.mjs · 字符偏移 260 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-12 bytes 到 float 再到整数:f=Σ byte_i / 256^(i+1);4 bytes 时区间 [0,1),p=floor(float*size)。m 将每组浮点映射固定 size。

chunks/nVEredkt.mjs · 字符偏移 620 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-13 洗牌是不放回抽样:h 建立 0..size-1 pool,各浮点 floor(f*剩余长度) 后 splice 出一个索引;超过 size 样本会抛异常。不是简单 floor(f*初始size) 去重。

chunks/nVEredkt.mjs · 字符偏移 789 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-14 Dice 确切公式:BH 配置 size=10001/count=1。Bt 要 4 bytes→float→floor(float*10001)→除100→toFixed(2)→Number,值范围 0 至 100。

chunks/D04PJvcv.mjs · 字符偏移 30267 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-15 Dice 预览组件禁用:getResultProps 对 Dice 输出 disabled:true,target:0,condition:above,status:positive,result。复用游戏结果可视化组件,但在公平验证页不是发起下注的按钮。

chunks/BH2ZjAyW.mjs · 字符偏移 2855 · static-observation

格式化上下文 · 第5行起;原始精确片段保留在证据JSON。打开带行号阅读版

var s = {
    baccarat: { id: `PFZC7G` },
    bars: { id: `yIoFdU` },
    blackjack: { id: `Q5dASO` },
    cases: { id: `446OEB` },
    packs: { id: `BUDicL` },
    tarot: { id: `dHmH2K` },
    diamonds: { id: `Ad2hMR` },
    dice: { id: `u9l1aF` },
    darts: { id: `40veEG` },
    drill: { id: `BHkBxs` },
    flip: { id: `0iNLjx` },
    hilo: { id: `bGF8ZZ` },
    keno: { id: `EzCrXK` },
    limbo: { id: `lC-tRi` },
    dragonTower: { id: `9rAkpJ` },
    mines: { id: `p09XJP` },
    moles: { id: `t1Rc4F` },
    plinko: { id: `8Ulcn1` },
    primedice: { id: `fRxBAu` },
    pump: { id: `1Dmkw6` },
    chicken: { id: `bM0VBQ` },
    roulette: { id: `uj-Q50` },
    rockpaperscissors: { id: `sIqe-t` },
    slotsSamurai: { id: `RzYHmo` },
FAIR-16 轮盘与轮盘分段:roulette 取一组4bytes映射 floor(f*37) 为 0..36;wheel size=Number(wheelSegments),取 floor(f*segments),后续按照风险/segments 的赔率表展示。

chunks/D04PJvcv.mjs · 字符偏移 33513 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-17 Mines / Keno:Mines 对 size25 count24 的不放回抽样取前 minesCount;Keno size40 count10 抽10个索引。解释层 Mines 坐标 x=index%5+1,y=5-floor(index/5)。

chunks/D04PJvcv.mjs · 字符偏移 31939 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-18 Plinko:从 count20,size2 得20个0/1,再 slice 到 plinkoRow;getResultProps 把真假映成左右 L/R。风险不会改变随机路径,只传给展示层选赔率。

chunks/D04PJvcv.mjs · 字符偏移 32702 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-19 Flip 的边界:每组4bytes float > .5 为 heads,否则 tails;等于 .5 走 tails。

chunks/D04PJvcv.mjs · 字符偏移 31160 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-20 Limbo / Crash / Slide:Limbo 用4bytes浮点 floor(f*2^24),最终 max(1,2^24/(int+1)*.99);Crash / Slide 使用 HMAC(hash,seed)前8hex解析32bit,分别边际1%/2%,同 max(1,2^32/(int+1)*(1-edge))。

chunks/nVEredkt.mjs · 字符偏移 1150 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-21 Zoo 的映射:HMAC(hash,seed)前三个8hex窗口转整数 %20;BH 以权重 1/1/2/2/4/10 把20槽映为 lion/cheetah/elephant/crocodile/rhino/penguin。

chunks/D04PJvcv.mjs · 字符偏移 38421 · static-observation

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,
FAIR-22 Dragon Tower:难度配置提供 count/size;结果生成九组 bytes,每组独立不放回抽 count 个安全位置。easy3/4,medium2/3,hard1/2,expert1/3,master1/4。解释 steps 用一组配置,不能直接当作全部九轮展示。

chunks/D04PJvcv.mjs · 字符偏移 30523 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-23 Darts:取两组float,第一个 rotation,第二个 distance=sqrt(float)/2,乘数由 ht(rotation,distance,difficulty) 映射;具体 ht 内的赔率/得分未在此子任务深读。

chunks/D04PJvcv.mjs · 字符偏移 29720 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),

Bx_kQ6xw 中 multiplier 实现尚未在此账本深读。

FAIR-24 Pump / Chicken:不放回抽样后 +1,按风险取前1/3/5/10候选;最小候选决定爆点/死亡点,具体展示乘数由游戏专属 helper 决定。

chunks/D04PJvcv.mjs · 字符偏移 33197 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-25 Slots 普通每轮5个索引:slots / Tome 每轮5浮点,前4映 size30,第5映size41;根据 roundIndex 对完整序列 slice 当前5项,负值截至0。

chunks/D04PJvcv.mjs · 字符偏移 34114 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-26 Samurai 切换序列游标:fn 对 HMAC bytes DataView getUint32 big-endian /2^32;pn 根据起始float游标计算所需HMAC轮,slice 段。普通轮18floats、特殊轮12,offset=(round-previousSpecial)*18+previousSpecial*12。

chunks/D04PJvcv.mjs · 字符偏移 34861 · static-observation

格式化上下文 · 第1404行起;原始精确片段保留在证据JSON。打开带行号阅读版

async function fn(e, t, n, r) {
  let i = await st({ hmacMessage: `${t}:${n}:${r}`, serverSeed: e }),
    a = new DataView(i.buffer, i.byteOffset, i.byteLength);
  return Array.from(Array($).keys()).map((e) => {
    if (Q === 6) {
      let t = a.getUint16(e * 6, !1),
        n = a.getUint32(e * 6 + 2, !1);
      return (t * 2 ** 32 + n) / sn;
    }
    return a.getUint32(e * 4, !1) / sn;
  });
}
async function pn(e, t, n, r, i) {
  let a = Math.floor(r / $),
    o = Math.ceil((r + i) / $),
    s = Array.from(Array(o - a).keys()),
    c = await Promise.all(s.map(async (r) => await fn(e, t, n, r + a))),
    l = ne(c),
    u = r - a * $;
  return l.slice(u, u + i);
}
var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
FAIR-27 Samurai 随机浮点映符号:BH 累计 outer/inner 概率并 find 累计阈值>float 的符号,普通5列外侧列0/4使用outer,特殊3列使用inner。输入 isSpecial 和roundIndex 决定展示类型。

chunks/BH2ZjAyW.mjs · 字符偏移 3535 · static-observation

格式化上下文 · 第5行起;原始精确片段保留在证据JSON。打开带行号阅读版

var s = {
    baccarat: { id: `PFZC7G` },
    bars: { id: `yIoFdU` },
    blackjack: { id: `Q5dASO` },
    cases: { id: `446OEB` },
    packs: { id: `BUDicL` },
    tarot: { id: `dHmH2K` },
    diamonds: { id: `Ad2hMR` },
    dice: { id: `u9l1aF` },
    darts: { id: `40veEG` },
    drill: { id: `BHkBxs` },
    flip: { id: `0iNLjx` },
    hilo: { id: `bGF8ZZ` },
    keno: { id: `EzCrXK` },
    limbo: { id: `lC-tRi` },
    dragonTower: { id: `9rAkpJ` },
    mines: { id: `p09XJP` },
    moles: { id: `t1Rc4F` },
    plinko: { id: `8Ulcn1` },
    primedice: { id: `fRxBAu` },
    pump: { id: `1Dmkw6` },
    chicken: { id: `bM0VBQ` },
    roulette: { id: `uj-Q50` },
    rockpaperscissors: { id: `sIqe-t` },
    slotsSamurai: { id: `RzYHmo` },
FAIR-28 Moles 独立轮抽样:molesCount 默认1:1时8轮,否则9轮;各轮抽指定数量的位置(size7)。通用步骤只解释单轮 count,而最终结果包含多轮。

chunks/D04PJvcv.mjs · 字符偏移 32174 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),
FAIR-29 扑克牌存在两种算法:Blackjack/Hilo/Baccarat 调 cards helper g,按固定size52直接映射(可重复)。VideoPoker 调不放回shuffle size52,前10分成初始5/后续5。Baccarat最终只取前6并套补牌规则。

chunks/nVEredkt.mjs · 字符偏移 1011 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-30 卡牌解释字节与结果总序列不同:cards helper 的 count 未传时默认128,因此 Blackjack/Hilo计算器final实际生成128号码,而 BH步骤 count 分别52/100,Baccarat最终只slice6。不能把解释表长度当作生成牌序列总长度。

chunks/D04PJvcv.mjs · 字符偏移 28922 · static-observation

格式化上下文 · 第1153行起;原始精确片段保留在证据JSON。打开带行号阅读版

var jt = async ({ clientSeed: e, serverSeed: t, nonce: n }) => ({
    type: `cardNumbers`,
    value: (await X({ serverSeed: t, clientSeed: e, nonce: n })).slice(0, 6),
  }),
  Mt = (e, t, n) => {
    let r = ft[e],
      i = 0,
      a = r.map((e) => {
        let t = i;
        return ((i += e.probability), { multiplier: e.multiplier, lowerBound: t, upperBound: i });
      });
    return t.map((e) => {
      let t = a.find((t) => e >= t.lowerBound && e < t.upperBound);
      return Math.floor(((t?.multiplier || 0) / n) * 100) / 100;
    });
  },
  Nt = async ({ clientSeed: e, serverSeed: t, nonce: n, barsDifficulty: r, barsTilesCount: i }) => {
    let a = G.bars.config.count * Q,
      o = await J({ serverSeed: t, clientSeed: e, nonce: n, byteCount: a });
    return {
      type: `bars`,
      value: {
        board: Mt(
          r,
          P(o, Q).map((e) => Y({ bytes: e })),

仅指计算器适配器,不代表真实服务端牌堆长度。

FAIR-31 概率表游戏:bars/cases/packs/tarot/drill 将 float 交给各游戏专属概率/赔率映射;tarot 以侧位/中位不同表排序乘数并累积概率匹配。概率表不都存在 BH 通用配置里。

chunks/D04PJvcv.mjs · 字符偏移 36864 · static-observation

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,
FAIR-32 错误与 loading:calculate 统一 catch 包装 Error;result store 初次或切换game清data且loading,同game保留旧data且loading=false;步骤 store 完成或失败才set。页面把空 HMAC key 特定错误视作等待输入/loader而非错误面板。

chunks/D04PJvcv.mjs · 字符偏移 40016 · static-observation

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,
FAIR-33 两套响应式计算:wt 内 effect 调 finalResult.calculate(inputValues);An steps UI effect 调 stepsMeta.calculate(inputValues),另外 game变更把steps loading置true。因此任何输入变化触发重新计算。

nodes/163.RHM72Gys.mjs · 字符偏移 47809 · static-observation

格式化上下文 · 第3610行起;原始精确片段保留在证据JSON。打开带行号阅读版

function An(e, n) {
  j(n, !0);
  let r = () => k(v, `$inputValues`, c),
    i = () => k(S, `$stepsMeta`, c),
    o = () => k(I, `$i18n`, c),
    [c, u] = f(),
    m = {
      [ue]: { component: hn, message: $.seedsToBytes },
      [me]: { component: cn, message: $.bytesToNumber },
      [fe]: { component: Cn, message: $.numberToShuffle },
      [ge]: { component: En, message: $.rawToEdged },
      [ce]: { component: vn, message: $.seedsToHex },
      [de]: { component: fn, message: $.hexToDecimal },
      [_e]: { component: En, message: $.rawToEdged },
    },
    { inputValues: v, stepsMeta: S } = X();
  a(() => {
    S.calculate(r());
  });
  let C = y(() => r()?.game);
  (S.update((e) => ({ ...e, loading: !0 })),
    a(() => {
      (O(C), S.update((e) => ({ ...e, loading: !0 })));
    }));
  let M = y(() => i()?.error?.message === `HMAC key data must not be empty`);
FAIR-34 异步结果无世代保护:Fn 的两个 calculate 都 await 后无请求版本或Abort条件直接set。快速输入可让旧输入的Promise晚完成而覆盖新输入结果。game字段只保护跨游戏的resultProps,无法防止同game旧seed/nonce被显示。是静态风险,未测运行发生概率。

chunks/D04PJvcv.mjs · 字符偏移 40280 · analyst-inference

格式化上下文 · 第1425行起;原始精确片段保留在证据JSON。打开带行号阅读版

var mn = 18,
  hn = 12,
  gn = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    roundIndex: r,
    isSpecial: i,
    previousSpecialSpinsCount: a,
  }) => {
    let o = i ? hn : mn,
      s = await pn(t, e, n, (r - a) * mn + a * hn, o);
    return i ? dn(s) : ln(s);
  },
  _n = async ({
    clientSeed: e,
    serverSeed: t,
    nonce: n,
    samuraiSlotsRound: r,
    samuraiSlotsIsSpecial: i,
    samuraiSlotsPreviousSpecialSpinsCount: a,
  }) => ({
    type: `samurai`,
    value: await gn({
      clientSeed: e,

没有受控运行复现;实际WebCrypto完成顺序未知。

FAIR-35 动态模块装载无世代保护:wt 按游戏动态import预览组件,then/catch 使用当时当前L而不是冻结旧game,没有 generation token。极快速切游戏可能把旧module记到新game。静态风险未运行复现。

chunks/D04PJvcv.mjs · 字符偏移 24382 · analyst-inference

格式化上下文 · 第458行起;原始精确片段保留在证据JSON。打开带行号阅读版

function wt(l, m) {
  D(m, !0);
  let g = () => T(ne, `$inputValues`, j),
    _ = () => T(te, `$navigating`, j),
    v = () => T(ie, `$mobileView`, j),
    b = () => T(I, `$finalResult`, j),
    O = () => T(N, `$i18n`, j),
    ee = () => T(re, `$resultProps`, j),
    [j, M] = s(),
    P = {
      baccarat: () =>
        A(
          () => import(`./u5vu_TcO.mjs`),
          __vite__mapDeps([
            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
            24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
            46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
            68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
            90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
            109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
            126, 127, 128, 129, 130, 131, 132, 133,
          ]),
          import.meta.url,
        ),
      bars: () =>
FAIR-36 展示步骤舍入:解释 bytes row 使用Number(value).toFixed(12).split,结果算法用完整JS number;12位只是解释层格式化,不能拿显示的小数当作内部完整输入。

chunks/nVEredkt.mjs · 字符偏移 1847 · static-observation

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-37 Shuffle 解释零索引高亮问题:说明表 T 的 nextNumber:h[r+1]||-1 把合法0转成-1。因此下一次选中首项时解释高亮可能缺失。实际 h 抽样不使用该字段;这是展示层问题,不改变随机结果。

chunks/nVEredkt.mjs · 字符偏移 2873 · analyst-inference

格式化上下文 · 第6行起;原始精确片段保留在证据JSON。打开带行号阅读版

var o = a(),
  s = new Set([`true`, `on`, `1`, `yes`]).has(`false`) ? 6 : 4,
  c = Math.floor(32 / s) * s,
  l = ({ clientSeed: e, byteCount: t, nonce: n }) =>
    i(0, Math.ceil(t / c)).map((t) => `${e}:${n}:${t}`),
  u = ({ hmacBuffers: e, byteCount: n }) => t(r(e.map((e) => Array.from(e).slice(0, c))), n),
  d = async ({ serverSeed: e = ``, clientSeed: t = ``, nonce: n = ``, byteCount: r }) =>
    u({
      hmacBuffers: await Promise.all(
        l({ clientSeed: t, nonce: n, byteCount: r }).map(async (t) =>
          A({ hmacMessage: t, serverSeed: e }),
        ),
      ),
      byteCount: r,
    }),
  f = ({ bytes: e }) => e.reduce((e, t, n) => e + t / 256 ** (n + 1), 0),
  p = ({ float: e, multiplier: t }) => Math.floor(e * t),
  m = ({ bytes: t, size: n }) =>
    e(t, s)
      .map((e) => f({ bytes: e }))
      .map((e) => Math.floor(e * n)),
  h = ({ bytes: t, size: n }) => {
    let r = i(0, n),
      a = e(t, s).map((e) => f({ bytes: e }));
    if (a.length > n) throw Error(`cant take more than ${n} items`);
FAIR-38 赔率显示仍依赖请求:Plinko 和 Wheel 解释组件调用 payoutsStore.fetch();对应源码嵌有查询 PlinkoPayouts/info.plinkoPayouts 与 WheelPayouts/info.wheelPayouts,分 risk/rows 整理。种子→float本地;赔率表并不全是离线内嵌。

nodes/163.RHM72Gys.mjs · 字符偏移 8217 · static-observation

格式化上下文 · 第576行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Qe(e, n) {
  j(n, !0);
  let r = () => k(Te, `$payoutsStore`, o),
    a = () => k(I, `$i18n`, o),
    [o, c] = f(),
    u = S(n, `segments`, 3, 0),
    m = S(n, `sharedTextProps`, 19, () => ({})),
    _ = y(() => (n.risk && r()?.[n.risk]?.[u()]) || []);
  Te.fetch();
  var v = t(),
    x = p(v),
    C = (e) => {
      U(e, {});
    },
    N = (e) => {
      var t = Ze(),
        r = T(t);
      z(
        r,
        M({ tag: `span`, type: `body`, size: `md` }, m, {
          children: (e, t) => {
            w();
            var r = A();
            (s(
              (e) =>
FAIR-39 赔率请求不带 seed 的本地调用:捕获对应 payouts store fetch 使用 requestClient(query,{}),读取data.info填store;这一调用现场不携带 clientSeed/serverSeed/nonce。requestClient环境与其他模块行为未在此账本展开。

chunks/HIqQPziK.mjs · 字符偏移 2880 · static-observation

格式化上下文 · 第16行起;原始精确片段保留在证据JSON。打开带行号阅读版

var _ = r.plinko,
  {
    config: v,
    requestClient: y,
    httpRequestClient: ee,
  } = g({ name: _, slug: `plinko`, apiUrl: l, httpUrl: c(s), getSession: o }),
  b = {
    kind: `Document`,
    definitions: [
      {
        kind: `OperationDefinition`,
        operation: `query`,
        name: { kind: `Name`, value: `PlinkoPayouts` },
        selectionSet: {
          kind: `SelectionSet`,
          selections: [
            {
              kind: `Field`,
              name: { kind: `Name`, value: `info` },
              selectionSet: {
                kind: `SelectionSet`,
                selections: [
                  { kind: `Field`, name: { kind: `Name`, value: `__typename` } },
                  {
                    kind: `Field`,
FAIR-40 入口上下文和焦点:Mn用oe(pageStore)建立公平上下文ie,挂输入表/preview/steps;onMount保存activeElement并加autofocus,onDestroy删除并恢复focus。

nodes/163.RHM72Gys.mjs · 字符偏移 49415 · static-observation

格式化上下文 · 第3734行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Mn(e, t) {
  j(t, !0);
  let r = y(() => t.data.seo),
    i = oe(F);
  ie(i);
  let a = n(null);
  (N(() => {
    (v(a, document.activeElement, !0), O(a).setAttribute(`autofocus`, `true`));
  }),
    P(() => {
      O(a) && (O(a).removeAttribute(`autofocus`), O(a).focus());
    }));
  var o = jn(),
    s = p(o);
  G(s, {
    get seo() {
      return O(r);
    },
  });
  var c = h(s, 2),
    l = T(c);
  ae(l, {});
  var u = h(l, 2);
  (ne(u, {}), An(h(u, 2), {}), D(c), g(e, o), E());
}
L01 游戏页先组装业务上下文,再交给实际游戏组件:load函数en读取game slug、规范化titan-gaming-cases路由;并发读取游戏资料、SEO、deposit bonus feature flag、收藏元数据;拿到providerGroup.id后再查关注状态和关注人数。allowRollover=false且flag启用时另取activeRollovers。

nodes/13.CjFrHUpN.mjs · 字符偏移 46452 · 静态源码

格式化上下文 · 第135行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Kt = {
    kind: `Document`,
    definitions: [
      {
        kind: `OperationDefinition`,
        operation: `query`,
        name: { kind: `Name`, value: `SlugKuratorGameIndex` },
        variableDefinitions: [
          {
            kind: `VariableDefinition`,
            variable: { kind: `Variable`, name: { kind: `Name`, value: `slug` } },
            type: {
              kind: `NonNullType`,
              type: { kind: `NamedType`, name: { kind: `Name`, value: `String` } },
            },
          },
        ],
        selectionSet: {
          kind: `SelectionSet`,
          selections: [
            {
              kind: `Field`,
              name: { kind: `Name`, value: `slugKuratorGame` },
              arguments: [
                {

请求包装B/V的缓存与认证策略没有在本条中展开。

L02 并发加载中的单个失败被降级为空值:Ae对每个Promise加catch(()=>void 0),然后Promise.all。这是游戏页De、首页ve所导入的r别名。

chunks/9eOfpkDu.mjs · 字符偏移 26914 · 静态源码

格式化上下文 · 第1171行起;原始精确片段保留在证据JSON。打开带行号阅读版

async function Ae(e) {
  return await Promise.all(e.map((e) => Promise.resolve(e).catch(() => void 0)));
}
function je() {
  let e = new Date();
  return (e.setSeconds(0, 0), e.toISOString());
}
export { Oe as i, je as n, Ae as r, ke as t };
L03 异步检查用请求序号避免旧结果覆盖新游戏:wr闭包计数++e,每次查询记录i,返回current:i===e与gameId;失败返回null,调用方ge仅在current为真时更新K。

nodes/13.CjFrHUpN.mjs · 字符偏移 77436 · 静态源码

格式化上下文 · 第4443行起;原始精确片段保留在证据JSON。打开带行号阅读版

function wr() {
  let e = 0;
  return async function (t, n, r) {
    let i = ++e;
    try {
      let a = await B({ load: t, doc: Cr, variables: { userId: n, gameId: r } });
      return { current: i === e, gameId: a?.user?.userHasActiveBetsOnGame ? r : null };
    } catch {
      return { current: i === e, gameId: null };
    }
  };
}
var Tr = new Set([`$$slots`, `$$events`, `$$legacy`]),
  Er = E(`<div><!></div>`);
function Dr(e, t) {
  (F(t, !0), k(t, Tr));
  var n = Er();
  let r;
  var a = O(n);
  (L(a, () => t.children ?? w),
    j(n),
    s(
      () =>
        (r = i(n, 1, `flex flex-col svelte-1ix22wc`, null, r, {
          breathe: t.loading,

这是静态逻辑;未执行并发切页实验。

L04 停用游戏存在完成未结回合的例外通道:仅在active=false且类型为pragmatic,或finishRoundsOnDisabledGamesEnabled且非stake游戏时发userHasActiveBetsOnGame查询;_e只在返回gameId与当前游戏id一致时为真。

nodes/13.CjFrHUpN.mjs · 字符偏移 86420 · 静态源码

格式化上下文 · 第5048行起;原始精确片段保留在证据JSON。打开带行号阅读版

function $r(e, r) {
  F(r, !0);
  let c = () => N(ce, `$page`, R),
    l = () => N(Pe, `$mobileView`, R),
    d = () => N(U, `$i18n`, R),
    g = () => N(q, `$currency`, R),
    b = () => N(Ee, `$sidebarView`, R),
    C = () => N(Fe, `$leftSidebarSize`, R),
    ee = () => N(Ce, `$leftSidebarViewPrevious`, R),
    ne = () => N(Te, `$leftSidebarView`, R),
    T = () => N(Se, `$sidebarViewPrevious`, R),
    E = () => N(we, `$sidebarClosedInGamePage`, R),
    k = () => N(ct, `$theaterModeEnabled`, R),
    ae = () => N(B, `$kuratorGameStore`, R),
    I = () => N(pe, `$meta`, R),
    [R, se] = p(),
    B = Pt(),
    V = S(() => r.data.slugKuratorGame),
    W = S(() => r.data.isFollowingGameGroup),
    le = S(() => r.data.followingCount),
    ue = S(() => r.data.seo),
    de = S(() => r.data.depositBonusImprovementFlagEnabled),
    fe = S(() => r.data.userActiveRollovers),
    G = S(() => r.data.slugGameFavouriteMeta);
  r.data.slugKuratorGame && B.set(r.data.slugKuratorGame);

后端如何判断未结回合、是否允许实际请求,仍未知。

L05 游戏壳三分支:可玩/已停用/不存在:游戏store.active为真或_e为真时渲染children;明确active=false显示notActive;其他情况显示notFound。

nodes/13.CjFrHUpN.mjs · 字符偏移 88532 · 静态源码

格式化上下文 · 第5048行起;原始精确片段保留在证据JSON。打开带行号阅读版

function $r(e, r) {
  F(r, !0);
  let c = () => N(ce, `$page`, R),
    l = () => N(Pe, `$mobileView`, R),
    d = () => N(U, `$i18n`, R),
    g = () => N(q, `$currency`, R),
    b = () => N(Ee, `$sidebarView`, R),
    C = () => N(Fe, `$leftSidebarSize`, R),
    ee = () => N(Ce, `$leftSidebarViewPrevious`, R),
    ne = () => N(Te, `$leftSidebarView`, R),
    T = () => N(Se, `$sidebarViewPrevious`, R),
    E = () => N(we, `$sidebarClosedInGamePage`, R),
    k = () => N(ct, `$theaterModeEnabled`, R),
    ae = () => N(B, `$kuratorGameStore`, R),
    I = () => N(pe, `$meta`, R),
    [R, se] = p(),
    B = Pt(),
    V = S(() => r.data.slugKuratorGame),
    W = S(() => r.data.isFollowingGameGroup),
    le = S(() => r.data.followingCount),
    ue = S(() => r.data.seo),
    de = S(() => r.data.depositBonusImprovementFlagEnabled),
    fe = S(() => r.data.userActiveRollovers),
    G = S(() => r.data.slugGameFavouriteMeta);
  r.data.slugKuratorGame && B.set(r.data.slugKuratorGame);

children内部的身份验证与游戏启动协议不是这段门控。

L06 停用与缺失游戏同时影响SEO与奖金提示:缺失游戏生成notFound SEO;停用/缺失将noindex置true。奖金改进flag、allowRollover=false和当前货币未豁免的activeRollover组合成je,用于提示notAllowedWithActiveDepositBonus。

nodes/13.CjFrHUpN.mjs · 字符偏移 86690 · 静态源码

格式化上下文 · 第5048行起;原始精确片段保留在证据JSON。打开带行号阅读版

function $r(e, r) {
  F(r, !0);
  let c = () => N(ce, `$page`, R),
    l = () => N(Pe, `$mobileView`, R),
    d = () => N(U, `$i18n`, R),
    g = () => N(q, `$currency`, R),
    b = () => N(Ee, `$sidebarView`, R),
    C = () => N(Fe, `$leftSidebarSize`, R),
    ee = () => N(Ce, `$leftSidebarViewPrevious`, R),
    ne = () => N(Te, `$leftSidebarView`, R),
    T = () => N(Se, `$sidebarViewPrevious`, R),
    E = () => N(we, `$sidebarClosedInGamePage`, R),
    k = () => N(ct, `$theaterModeEnabled`, R),
    ae = () => N(B, `$kuratorGameStore`, R),
    I = () => N(pe, `$meta`, R),
    [R, se] = p(),
    B = Pt(),
    V = S(() => r.data.slugKuratorGame),
    W = S(() => r.data.isFollowingGameGroup),
    le = S(() => r.data.followingCount),
    ue = S(() => r.data.seo),
    de = S(() => r.data.depositBonusImprovementFlagEnabled),
    fe = S(() => r.data.userActiveRollovers),
    G = S(() => r.data.slugGameFavouriteMeta);
  r.data.slugKuratorGame && B.set(r.data.slugKuratorGame);

je提示是否同时阻止下层游戏启动,不能仅凭壳层推断。

L07 剧院模式和窄布局由共享壳控制:nn订阅theaterModeEnabled给parent加theatre;ResizeObserver式绑定把容器宽度写入store并通过be(width)判断mobile,传给children。另在game-layout用width<=930定义responsive。

nodes/13.CjFrHUpN.mjs · 字符偏移 48053 · 静态源码

格式化上下文 · 第2138行起;原始精确片段保留在证据JSON。打开带行号阅读版

function nn(e, t) {
  F(t, !0);
  let r = () => N(ct, `$theaterModeEnabled`, a),
    [a, o] = p(),
    c = je(),
    l = n(!1);
  var u = tn();
  let d;
  var f = O(u),
    m = O(f);
  (L(
    m,
    () => t.children ?? w,
    () => ({ mobile: M(l) }),
  ),
    j(f),
    ie(
      f,
      (e, t) => ke?.(e, t),
      () => (e) => {
        (c.set(e.width), x(l, be(e.width), !0));
      },
    ),
    j(u),
    s(() => (d = i(u, 1, `parent svelte-1powyzj`, null, d, { theatre: r() }))),
L08 桌面游戏页自动腾出侧栏空间:首次挂载且非mobile且左栏不是small时,保存之前左/右sidebar值;右栏hidden且未记录用户关闭则切recommendations;可见右栏时将左栏minimized;等250ms结束变更状态。

nodes/13.CjFrHUpN.mjs · 字符偏移 87199 · 静态源码

格式化上下文 · 第5048行起;原始精确片段保留在证据JSON。打开带行号阅读版

function $r(e, r) {
  F(r, !0);
  let c = () => N(ce, `$page`, R),
    l = () => N(Pe, `$mobileView`, R),
    d = () => N(U, `$i18n`, R),
    g = () => N(q, `$currency`, R),
    b = () => N(Ee, `$sidebarView`, R),
    C = () => N(Fe, `$leftSidebarSize`, R),
    ee = () => N(Ce, `$leftSidebarViewPrevious`, R),
    ne = () => N(Te, `$leftSidebarView`, R),
    T = () => N(Se, `$sidebarViewPrevious`, R),
    E = () => N(we, `$sidebarClosedInGamePage`, R),
    k = () => N(ct, `$theaterModeEnabled`, R),
    ae = () => N(B, `$kuratorGameStore`, R),
    I = () => N(pe, `$meta`, R),
    [R, se] = p(),
    B = Pt(),
    V = S(() => r.data.slugKuratorGame),
    W = S(() => r.data.isFollowingGameGroup),
    le = S(() => r.data.followingCount),
    ue = S(() => r.data.seo),
    de = S(() => r.data.depositBonusImprovementFlagEnabled),
    fe = S(() => r.data.userActiveRollovers),
    G = S(() => r.data.slugGameFavouriteMeta);
  r.data.slugKuratorGame && B.set(r.data.slugKuratorGame);

离开游戏后的完整恢复函数不在本条检验范围。

L09 首页由11个数据源并发拼接:首页loader并发VIP、recent、trending slots、player counts、sports、SEO、sweeps集合、poker、heroes内容、promotion窗口、personalised推荐;heroes存在时用Xe匹配过滤promotion;CMS homepage字段覆盖SEO兜底。

nodes/55.BHHpgWjN.mjs · 字符偏移 16887 · 静态源码

格式化上下文 · 第304行起;原始精确片段保留在证据JSON。打开带行号阅读版

var gt = {
    kind: `Document`,
    definitions: [
      {
        kind: `OperationDefinition`,
        operation: `query`,
        name: { kind: `Name`, value: `GetPlayerCountByScope` },
        selectionSet: {
          kind: `SelectionSet`,
          selections: [
            {
              kind: `Field`,
              name: { kind: `Name`, value: `playerCountByScope` },
              selectionSet: {
                kind: `SelectionSet`,
                selections: [
                  { kind: `Field`, name: { kind: `Name`, value: `sportsbookPlayerCount` } },
                  { kind: `Field`, name: { kind: `Name`, value: `casinoPlayerCount` } },
                ],
              },
            },
          ],
        },
      },
    ],

Xe的promotion匹配标准、本次用户是否触发每个源,未运行确认。

L10 推荐列表处理与游戏目录读取不同:trending读取recommended-slots组,offset0、limit50、popular7d;personalised读取recommendedGamesByUser,copy后按Number(isBlocked)升序排列,保留modelVersion和sequenceId;空结果返回null。

nodes/55.BHHpgWjN.mjs · 字符偏移 15796 · 静态源码

格式化上下文 · 第304行起;原始精确片段保留在证据JSON。打开带行号阅读版

var gt = {
    kind: `Document`,
    definitions: [
      {
        kind: `OperationDefinition`,
        operation: `query`,
        name: { kind: `Name`, value: `GetPlayerCountByScope` },
        selectionSet: {
          kind: `SelectionSet`,
          selections: [
            {
              kind: `Field`,
              name: { kind: `Name`, value: `playerCountByScope` },
              selectionSet: {
                kind: `SelectionSet`,
                selections: [
                  { kind: `Field`, name: { kind: `Name`, value: `sportsbookPlayerCount` } },
                  { kind: `Field`, name: { kind: `Name`, value: `casinoPlayerCount` } },
                ],
              },
            },
          ],
        },
      },
    ],

模型如何计算推荐、子组件是否上报sequenceId需另查。

L11 首页将异构数据适配成统一group/cards结构:recent、trending、personalised、sports和originals在Mn中各转成group加cards。personalised另保留modelVersion/sequenceId;Originals从kuratorCollection按stake-originals找组并map groupGamesList.game。

nodes/55.BHHpgWjN.mjs · 字符偏移 44228 · 静态源码

格式化上下文 · 第2372行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Mn(e, r) {
  j(r, !0);
  let i = () => k(W, `$i18n`, l),
    o = () => k(re, `$locale`, l),
    c = () => k(te, `$page`, l),
    [l, _] = u(),
    y = He(Z.type),
    b = g(() => r.data.vipProgress),
    x = g(() => r.data.userRecentGameList),
    S = g(() => r.data.trendingGamesList),
    w = g(() => r.data.trendingSportsList),
    E = g(() => r.data.heroes),
    A = g(() => r.data.promotions),
    M = g(() => r.data.seo),
    N = g(() => r.data.kuratorCollection),
    F = g(() => r.data.personalisedRecommendationGames),
    I = g(() => ({
      group: {
        slug: `recent-games`,
        to: `/casino/recent`,
        icon: `continue`,
        translation: i()._(ze.recentGames),
        gameCount: 0,
      },
      cards: O(x)?.map((e) => e) || [],
L12 访客首页与登录首页走不同首屏分支:yn从meta.isAuthenticated分支:登录时nn接收vipProgress,未登录时pn;loading来自trending slots+trending sports是否都为空。后续登录和访客分别走活动区与heroes/promotions分支。

nodes/55.BHHpgWjN.mjs · 字符偏移 35950 · 静态源码

格式化上下文 · 第1751行起;原始精确片段保留在证据JSON。打开带行号阅读版

function yn(e, n) {
  j(n, !0);
  let r = () => k(U, `$isSportsbookEnabledForRegion`, a),
    i = () => k(v, `$meta`, a),
    [a, o] = u(),
    c = b(n, `heroes`, 19, () => []),
    h = b(n, `promotions`, 19, () => []),
    _ = b(n, `personalisedGames`, 3, null),
    { meta: v } = le(),
    y = g(
      () => [...(n.trendingGames?.cards ?? []), ...(n.trendingSports?.cards ?? [])].length === 0,
    ),
    x = g(r);
  var S = t(),
    w = d(S);
  (m(
    w,
    () => $e,
    (e, r) => {
      r(e, {
        children: (e, r) => {
          var a = t(),
            o = d(a);
          (m(
            o,

骨架的终止条件与网络状态是否完全一致仍需运行检查。

L13 受限侧栏入口由共用链接组件转成注册弹窗:qh点击处理先通知onclick;openAuthModal为真则preventDefault并Ui({tab:register,source:sidebar_link,ctaVariant:switch_to_login_link,ctaLabel:label});再上报点击。Favourites/Following/Recent都用!isAuthenticated传入openAuthModal。

nodes/2.Dfb3gzrG.mjs · 字符偏移 119671 · 静态源码

格式化上下文 · 第6481行起;原始精确片段保留在证据JSON。打开带行号阅读版

function qh(e, n) {
  z(n, !0);
  let i = () => L(xt, `$route`, l),
    a = () => L(nt, `$navigating`, l),
    o = () => L(rt, `$page`, l),
    s = () => L(U, `$i18n`, l),
    [l, u] = h(),
    f = A(n, `iconOnly`, 3, !1),
    m = A(n, `count`, 3, void 0),
    g = A(n, `nested`, 3, !1),
    v = A(n, `exact`, 3, !1),
    y = A(n, `dataAnalytics`, 3, void 0),
    S = A(n, `dataTest`, 3, void 0),
    C = A(n, `showNewBadge`, 3, !1),
    E = A(n, `openAuthModal`, 3, !1),
    k = r(!1),
    ee = { click: () => O(() => n.onclick?.()) },
    te = (e) => {
      (ee.click(),
        E() &&
          (e.preventDefault(),
          Ui({
            tab: `register`,
            source: `sidebar_link`,
            ctaVariant: `switch_to_login_link`,

Ui最终如何规范化URL由其依赖负责;这不是后端鉴权证据。

L14 弹窗入口从URL驱动,并按需加载模态框注册表:mv读取modalPage.url.searchParams.modal;只有modal存在才渲染加载流程;import Dh3-ySZv.mjs失败记modal-graph-load-error并走fallback。

nodes/2.Dfb3gzrG.mjs · 字符偏移 199398 · 静态源码

格式化上下文 · 第12060行起;原始精确片段保留在证据JSON。打开带行号阅读版

function mv(e, n) {
  z(n, !0);
  let r = () => L(dc, `$modalPage`, i),
    [i, a] = h(),
    o = T(() => r().url.searchParams.get(`modal`)),
    s = () =>
      Se(
        () =>
          import(`../chunks/Dh3-ySZv.mjs`).then(
            (e) => e.default,
            (e) => (
              Wn(`[modal-graph-load-error] Failed to load modal graph`, { modal: I(o) }, e),
              null
            ),
          ),
        __vite__mapDeps([
          532, 2, 1, 6, 43, 92, 3, 4, 5, 7, 8, 9, 10, 11, 12, 426, 13, 14, 15, 16, 17, 125, 126,
          127, 18, 19, 38, 27, 39, 295, 296, 254, 20, 21, 23, 22, 24, 25, 26, 28, 100, 57, 101, 215,
          252, 533, 222, 31, 32, 33, 34, 35, 36, 37, 40, 41, 42, 44, 45, 46, 29, 47, 48, 49, 50, 51,
          52, 53, 54, 55, 56, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 534, 535,
          536, 216, 217, 73, 74, 537, 538, 539, 144, 143, 424, 244, 404, 471, 540, 301, 331, 360,
          541, 542, 543, 544, 304, 334, 545, 245, 246, 546, 247, 248, 547, 548, 180, 156, 133, 134,
          135, 136, 338, 339, 182, 253, 255, 549, 454, 414, 281, 98, 358, 99, 550, 551, 552, 213,
          553, 554, 555, 556, 340, 557, 93, 94, 277, 558, 559, 560, 455, 479, 199, 561, 562, 563,
          564, 123, 256, 257, 345, 565, 352, 353, 492, 515, 516, 566, 224, 567, 568, 569, 570, 571,
L15 弹窗系统统一处理组件加载、关闭和权限条件:Ra把所有query参数转modalProps,按modal名从Fa选定义;定义可提供restricted(meta)、persistent、darkOverlay、preventOutsideClose等。keydown Escape调用p;p调用onclose并在非persistent时移除URL弹窗。组件异步import设置loading、error并finally清除loading。

chunks/Dh3-ySZv.mjs · 字符偏移 156664 · 静态源码

格式化上下文 · 第5336行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Ra(e, n) {
  A(n, !0);
  let r = () => O(ze, `$modalPage`, o),
    a = () => O(c, `$meta`, o),
    [o, s] = l();
  L.set(Pa);
  let { meta: c } = V(),
    u = b(n, `loadingState`, 3, !1),
    d = _(() => {
      let e = {};
      return (
        r().url.searchParams.forEach((t, n) => {
          e[n] = t;
        }),
        e
      );
    }),
    f = _(() => (n.modal in Fa ? Fa[n.modal] : null));
  document.activeElement instanceof HTMLElement && document.activeElement.blur();
  let p = () => {
      (n.onclose?.(), D(x) || le(r()));
    },
    m = (e) => {
      let { key: t } = e;
      t === `Escape` && p();

restricted只是客户端UI规则;不能替代服务器权限。

L16 全局搜索开关独立于路由:桌面上Mac用Cmd+K,其他用Ctrl+K切换showTopSearch;搜索打开时才注册Esc关闭;mobile不创建这些快捷键。

nodes/2.Dfb3gzrG.mjs · 字符偏移 328599 · 静态源码

格式化上下文 · 第18778行起;原始精确片段保留在证据JSON。打开带行号阅读版

function UC(e, n) {
  z(n, !0);
  let r = () => L(Pn, `$showTopSearch`, i),
    [i, a] = h(),
    o = () => Pn.set(!r());
  var s = t(),
    c = _(s),
    l = (e) => {
      var t = HC(),
        n = _(t),
        i = (e) => {
          VC(e, { combination: [`cmd`, `k`], onkeydown: o });
        },
        a = (e) => {
          VC(e, { combination: [`ctrl`, `k`], onkeydown: o });
        };
      d(n, (e) => {
        ba.isMacOs ? e(i) : e(a, -1);
      });
      var s = b(n, 2),
        c = (e) => {
          VC(e, { combination: [`esc`], onkeydown: () => Pn.set(!1) });
        };
      (d(s, (e) => {
        r() && e(c);
L17 搜索模块按需加载,抓取包尚缺实现体:showTopSearch为真时动态导入Csd-SZM5.mjs;加载失败回调Pn.set(false)收起搜索。

nodes/2.Dfb3gzrG.mjs · 字符偏移 336561 · 静态源码

格式化上下文 · 第18828行起;原始精确片段保留在证据JSON。打开带行号阅读版

function XC(e, i) {
  z(i, !0);
  let l = () => L(Ce, `$meta`, ge),
    u = () => L(Le, `$loading`, ge),
    f = () => L(ze, `$intercepted`, ge),
    v = () => L(yr, `$mobileView`, ge),
    y = () => L(Zl, `$viewTransitionScrollTopDisabled`, ge),
    S = () => L(rt, `$page`, ge),
    E = () => L(U, `$i18n`, ge),
    O = () => L(nt, `$navigating`, ge),
    ee = () => L(ln, `$userTransactionEligibility`, ge),
    A = () => L(dn, `$kycUserInfo`, ge),
    te = () => L(qt, `$activeOffers`, ge),
    j = () => L(xt, `$route`, ge),
    ne = () => L(xo, `$walletCurrencies`, ge),
    re = () => L(yn, `$currency`, ge),
    ie = () => L(Ht, `$restrictedRegion`, ge),
    ae = () => L(Mt, `$casinoWidgets`, ge),
    oe = () => L(vr, `$cookieLevelUpVipFlag`, ge),
    se = () => L(Zc, `$sessionInfo`, ge),
    ce = () => L(Bt, `$restrictedRegionHandlingComplete`, ge),
    le = () => L(mo, `$totalBalanceAmount`, ge),
    ue = () => L(Pn, `$showTopSearch`, ge),
    fe = () => L(Sr, `$mobileLandscapeView`, ge),
    pe = () => L(wo, `$thirdPartyInPlay`, ge),

Csd-SZM5.mjs在当前outputs/stake-us-source/chunks不存在;仅有导入引用,需另次公开抓取补齐。

UI01 侧栏默认值及持久化:左栏默认minimized取决于配置或innerWidth<1200;leftSidebarView_v2从cookie读入,验证只接受minimized/expanded。subscribe首次跳过写入,后续变更写cookie。

chunks/CPX-EBFK.mjs · 字符偏移 707 · 静态源码

格式化上下文 · 第28行起;原始精确片段保留在证据JSON。打开带行号阅读版

var b = (e) => (e === `minimized` || e === `expanded` ? e : void 0),
  x = () =>
    r.navigation?.leftSidebarDefaultView === `minimized` || window.innerWidth < 1200
      ? `minimized`
      : `expanded`,
  S = t({ value: void 0, source: void 0 }),
  C = (() => {
    let e = `leftSidebarView_v2`,
      n = t(b(c(e)) || x());
    {
      let t = !1;
      n.subscribe((n) => {
        (t && s(e, n), (t = !0));
      });
    }
    return { ...n, toggle: () => n.update((e) => y[e]) };
  })(),
  w = [`chat`, `betslip`, `betsListBoard`, `hidden`, `recommendations`],
  T = (e) => {
    if (w.includes(e)) return e === `chat` && !r.engagement?.chatEnabled ? `hidden` : e;
  },
  E = () =>
    r.engagement?.chatEnabled && r.chat?.openByDefault && window.innerWidth > 720
      ? `chat`
      : `hidden`,
UI02 右栏状态经过白名单和能力检查:允许chat/betslip/betsListBoard/hidden/recommendations;禁用chat时已有chat值降级hidden;默认chat仅当chatEnabled、openByDefault、宽度>720成立。

chunks/CPX-EBFK.mjs · 字符偏移 987 · 静态源码

格式化上下文 · 第28行起;原始精确片段保留在证据JSON。打开带行号阅读版

var b = (e) => (e === `minimized` || e === `expanded` ? e : void 0),
  x = () =>
    r.navigation?.leftSidebarDefaultView === `minimized` || window.innerWidth < 1200
      ? `minimized`
      : `expanded`,
  S = t({ value: void 0, source: void 0 }),
  C = (() => {
    let e = `leftSidebarView_v2`,
      n = t(b(c(e)) || x());
    {
      let t = !1;
      n.subscribe((n) => {
        (t && s(e, n), (t = !0));
      });
    }
    return { ...n, toggle: () => n.update((e) => y[e]) };
  })(),
  w = [`chat`, `betslip`, `betsListBoard`, `hidden`, `recommendations`],
  T = (e) => {
    if (w.includes(e)) return e === `chat` && !r.engagement?.chatEnabled ? `hidden` : e;
  },
  E = () =>
    r.engagement?.chatEnabled && r.chat?.openByDefault && window.innerWidth > 720
      ? `chat`
      : `hidden`,
UI03 窄屏避免左右栏同时抢空间:右栏toggle当前值则hidden,否则新值;宽度<sidebarFullWidth时左栏minimized。切换左栏时相同窄屏条件把右栏hidden。widget分支toggle独立通知store。

chunks/CPX-EBFK.mjs · 字符偏移 1704 · 静态源码

格式化上下文 · 第91行起;原始精确片段保留在证据JSON。打开带行号阅读版

var F = (e) => {
    e.type === `sidebar`
      ? (A.update((t) => (t === e.value ? `hidden` : e.value)),
        window.innerWidth < d.sidebarFullWidth && C.set(`minimized`))
      : e.type === `leftSidebar`
        ? (C.update((e) => y[e]), window.innerWidth < d.sidebarFullWidth && A.set(`hidden`))
        : e.type === `widget`
          ? N.update((e) => !e)
          : A.set(`hidden`);
  },
  I = t(!1),
  L = {
    toggleRecommendationsSidebar: () => {
      F({ type: `sidebar`, value: `recommendations` });
    },
    toggleChatSidebar: () => {
      r.engagement?.chatEnabled && F({ type: `sidebar`, value: `chat` });
    },
    toggleMobileMenu: () => {
      F({ type: `leftSidebar` });
    },
    toggleBetsListBoard: () => {
      F({ type: `sidebar`, value: `betsListBoard` });
    },
    toggleBetslipSidebar: () => {
UI04 通知入口复用widget开关:toggleNotificationsSidebar与toggleNotificationsWidget都发送type:widget,value:notifications;F只toggle通知N。

chunks/CPX-EBFK.mjs · 字符偏移 2458 · 静态源码

格式化上下文 · 第91行起;原始精确片段保留在证据JSON。打开带行号阅读版

var F = (e) => {
    e.type === `sidebar`
      ? (A.update((t) => (t === e.value ? `hidden` : e.value)),
        window.innerWidth < d.sidebarFullWidth && C.set(`minimized`))
      : e.type === `leftSidebar`
        ? (C.update((e) => y[e]), window.innerWidth < d.sidebarFullWidth && A.set(`hidden`))
        : e.type === `widget`
          ? N.update((e) => !e)
          : A.set(`hidden`);
  },
  I = t(!1),
  L = {
    toggleRecommendationsSidebar: () => {
      F({ type: `sidebar`, value: `recommendations` });
    },
    toggleChatSidebar: () => {
      r.engagement?.chatEnabled && F({ type: `sidebar`, value: `chat` });
    },
    toggleMobileMenu: () => {
      F({ type: `leftSidebar` });
    },
    toggleBetsListBoard: () => {
      F({ type: `sidebar`, value: `betsListBoard` });
    },
    toggleBetslipSidebar: () => {

通知列表数据、已读mutation、排序未在这条定位。

UI05 Service Worker注册有10秒就绪边界:register /service-worker.js为classic;Promise.race等待ready、active状态或1e4超时;成功写registration store,失败返回false;unregister finally置null。

chunks/CPX-EBFK.mjs · 字符偏移 3356 · 静态源码

格式化上下文 · 第140行起;原始精确片段保留在证据JSON。打开带行号阅读版

var V = !!(navigator && `serviceWorker` in navigator),
  H = 1e4,
  U = (() => {
    let e = t(null),
      n = async () => {
        if (V)
          try {
            let e = await navigator.serviceWorker.getRegistration();
            e && (await e.unregister());
          } catch (e) {
            console.error(`ServiceWorkerRegistration unregister error`, e);
          } finally {
            e.set(null);
          }
      },
      r = async (e) => {
        await a((t) => {
          if (e.active) {
            t();
            return;
          }
          let n = (e) => {
            e?.target && `state` in e.target && e.target.state === `activated` && t();
          };
          if (e.installing) {

缓存策略在service-worker源码中,当前该文件未抓到。

UI06 存储不可用时降级内存存储:store2构造时试写__store2_test,失败则fake storage;同一API暴露local、session、page作用域。

chunks/DA93Lu4n.mjs · 字符偏移 3672 · 静态源码

格式化上下文 · 第160行起;原始精确片段保留在证据JSON。打开带行号阅读版

var W = t((e, t) => {
    (function (e, n) {
      var r = {
          version: `2.14.4`,
          areas: {},
          apis: {},
          nsdelim: `.`,
          inherit: function (e, t) {
            for (var n in e)
              t.hasOwnProperty(n) ||
                Object.defineProperty(t, n, Object.getOwnPropertyDescriptor(e, n));
            return t;
          },
          stringify: function (e, t) {
            return e === void 0 || typeof e == `function`
              ? e + ``
              : JSON.stringify(e, t || r.replace);
          },
          parse: function (e, t) {
            try {
              return JSON.parse(e, t || r.revive);
            } catch {
              return e;
            }
          },
UI07 本地store包装自动保存:J优先使用已存值,否则默认t;创建reactive store并subscribe每次set入本地storage。Y为key加namespace前缀。

chunks/DA93Lu4n.mjs · 字符偏移 7179 · 静态源码

格式化上下文 · 第423行起;原始精确片段保留在证据JSON。打开带行号阅读版

function J(e, t) {
  let n = G.default.has(e) ? G.default.get(e) : t,
    r = L(n);
  return (
    r.subscribe((t) => {
      G.default.set(e, t);
    }),
    r
  );
}
function Y(e) {
  return function (t, n) {
    return J(`${e}_${t}`, n);
  };
}
function X(e, t) {
  let n = I(e),
    r = Array.isArray(t) ? n || t : typeof t == `object` ? { ...t, ...(n || {}) } : n || t,
    i = L(r);
  F(e, r);
  {
    let t = !1;
    i.subscribe((n) => {
      (t && F(e, n), (t = !0));
    });
UI08 cookie store支持服务端值hydrate:X读取cookie,array直接默认或旧值,object合并默认/已有,primitive旧值或默认;首次写cookie,subscribe跳过初次,hydrate对cookie值尝试JSON.parse。

chunks/DA93Lu4n.mjs · 字符偏移 7350 · 静态源码

格式化上下文 · 第438行起;原始精确片段保留在证据JSON。打开带行号阅读版

function X(e, t) {
  let n = I(e),
    r = Array.isArray(t) ? n || t : typeof t == `object` ? { ...t, ...(n || {}) } : n || t,
    i = L(r);
  F(e, r);
  {
    let t = !1;
    i.subscribe((n) => {
      (t && F(e, n), (t = !0));
    });
  }
  let a = (t) => {
    let n = t[e];
    if (n)
      try {
        let e = JSON.parse(n);
        i.set(e);
      } catch {
        i.set(n);
      }
  };
  return { type: `cookie`, namespace: e, ...i, hydrate: a };
}
function Z(e) {
  return function (t, n) {

primitive用n||t意味着false/0会取默认;具体影响取决于调用默认值。

UI09 session store依赖组件上下文:subscribe前set/update抛错;setStoreContext创建store并绑定context;subscribe找到context后才替换set/update。

chunks/DA93Lu4n.mjs · 字符偏移 7914 · 静态源码

格式化上下文 · 第489行起;原始精确片段保留在证据JSON。打开带行号阅读版

function te(e, t) {
  let r = (e) => {
      throw Error(`Cannot ${e} session store before subscribing`);
    },
    o = {
      subscribe(e) {
        let n = i(t);
        return ((o.set = n.set), (o.update = n.update), n.subscribe(e));
      },
      set: () => r(`set`),
      update: () => r(`update`),
    };
  function s() {
    let r = a(e);
    return (n(t, r), r);
  }
  return { store: o, setStoreContext: s };
}
export {
  K as a,
  Y as c,
  W as d,
  U as f,
  $ as i,
  ee as l,
UI10 表单字段由独立状态及schema校验组成:字段有focus/value/touched/error/errorType/innerErrors/validating/validateOnChange;校验取得所有字段值后schema.validateAt;首次已改字段失焦后启用后续change校验。

chunks/DnayUKGm.mjs · 字符偏移 1696 · 静态源码

格式化上下文 · 第67行起;原始精确片段保留在证据JSON。打开带行号阅读版

function E({ value: t, fieldKey: n, schema: r, getStores: i, validateOptions: a }) {
  let s = o(!1),
    c = o(t),
    l = o(!1),
    u = o(null),
    d = o(null),
    p = o([]),
    m = o(!1),
    h = o(!1),
    g = t,
    _ = t,
    v = async () => {
      let e = i();
      if (e) {
        let t = f(e, (e) => e.getValue());
        m.set(!0);
        try {
          return (
            await r.validateAt(n, t, a),
            d.set(null),
            u.set(null),
            p.set([]),
            m.set(!1),
            null
          );

异步validation缺请求序号,快速值变化是否出现过期错误需运行验证。

UI11 提交先并发验证全部字段:handleSubmit置isSubmitting,Promise.all每字段validate;全为null才调用onSubmit。失败调用onInvalidSubmit,配置允许时把第一个input-error滚到center;结束清isSubmitting。

chunks/DnayUKGm.mjs · 字符偏移 2842 · 静态源码

格式化上下文 · 第141行起;原始精确片段保留在证据JSON。打开带行号阅读版

function A({
  initialValues: r,
  validationSchema: s,
  onSubmit: c,
  onInvalidSubmit: l,
  validateOptions: u,
  scrollToErrorOnSubmit: d,
}) {
  let p = {};
  x();
  let m = () => p;
  for (let e in r)
    p[e] = E({ value: r[e], fieldKey: e, schema: s, getStores: m, validateOptions: u });
  i(() => {
    g(p, (e) => e.unsubscribe());
  });
  let v = o(!1),
    y = async () => {
      if ((v.set(!0), (await b()).every((e) => e === null))) {
        let t = f(p, (t) => e(t.value));
        try {
          await c(t, D);
        } catch (e) {
          console.error(`handleSubmit`, { e });
        }
UI12 表单reset同时重置验证时机:reset取新值或initialValues,validateOnChange=false、重设initialValue/value、touched=false。

chunks/DnayUKGm.mjs · 字符偏移 3480 · 静态源码

格式化上下文 · 第141行起;原始精确片段保留在证据JSON。打开带行号阅读版

function A({
  initialValues: r,
  validationSchema: s,
  onSubmit: c,
  onInvalidSubmit: l,
  validateOptions: u,
  scrollToErrorOnSubmit: d,
}) {
  let p = {};
  x();
  let m = () => p;
  for (let e in r)
    p[e] = E({ value: r[e], fieldKey: e, schema: s, getStores: m, validateOptions: u });
  i(() => {
    g(p, (e) => e.unsubscribe());
  });
  let v = o(!1),
    y = async () => {
      if ((v.set(!0), (await b()).every((e) => e === null))) {
        let t = f(p, (t) => e(t.value));
        try {
          await c(t, D);
        } catch (e) {
          console.error(`handleSubmit`, { e });
        }
UI13 校验错误转换成当前语言消息:schema错误可返回{key,values},w按key选翻译模板和动态min/max参数;已带id/message的对象直接i18n翻译。

chunks/DnayUKGm.mjs · 字符偏移 1423 · 静态源码

格式化上下文 · 第51行起;原始精确片段保留在证据JSON。打开带行号阅读版

function w(t) {
  let n = t.message;
  if (n && typeof n == `object` && `key` in n) {
    let t = n.key,
      r = C[t];
    if (typeof r == `function`)
      try {
        return e(l)._(r(n.values));
      } catch {
        return t;
      }
    return r ? e(l)._(r) : t;
  }
  return n && typeof n == `object` && (`id` in n || `message` in n) ? e(l)._(n) : n;
}
var T = (e, t = s.usd) => (m(e) ? e : t);
function E({ value: t, fieldKey: n, schema: r, getStores: i, validateOptions: a }) {
  let s = o(!1),
    c = o(t),
    l = o(!1),
    u = o(null),
    d = o(null),
    p = o([]),
    m = o(!1),
    h = o(!1),
UI14 异步建议用防抖和最新任务守卫:input reactive派生每次设timeout,cleanup取消旧timeout;getOptions结果仅在o===当前timeout时resolve建议Promise。默认debounceMs=300。

chunks/DugrqFmF.mjs · 字符偏移 857 · 静态源码

格式化上下文 · 第69行起;原始精确片段保留在证据JSON。打开带行号阅读版

function U(e, t, n, r) {
  let i, a, o;
  return v(
    e,
    (e, r) => {
      i === void 0 && ((i = new Promise((e) => (a = e))), r(i));
      let s = setTimeout(async () => {
        let n = await t(e);
        o === s && (a(n), (i = void 0));
      }, n);
      return ((o = s), () => clearTimeout(s));
    },
    r,
  );
}
var W = C(`<div><!></div>`),
  G = C(`<div class="scroll-cont scrollY svelte-r75e5n"><!></div>`);
function K(n, o) {
  P(o, !0);
  let c = S(o, `maxHeight`, 3, 500),
    u = t(0);
  r(() => {
    (o.items, m(u, 0));
  });
  let f = { select: (e) => b(() => o.onselect?.(e)) },

这为通用autocomplete,不是尚缺的顶栏搜索实现。

UI15 自动补全支持循环键盘选择:Enter等待items并选中索引;Up从0绕到最后,Down从末尾绕到0;相关key preventDefault。H通过offsetTop/height检测并滚动到可见项。

chunks/DugrqFmF.mjs · 字符偏移 1285 · 静态源码

格式化上下文 · 第86行起;原始精确片段保留在证据JSON。打开带行号阅读版

function K(n, o) {
  P(o, !0);
  let c = S(o, `maxHeight`, 3, 500),
    u = t(0);
  r(() => {
    (o.items, m(u, 0));
  });
  let f = { select: (e) => b(() => o.onselect?.(e)) },
    h = (e) => f.select(e),
    _ = {
      async Enter() {
        let e = (await o.items)[M(u)];
        e && h(e);
      },
      async ArrowUp() {
        let e = await o.items;
        m(u, M(u) === 0 ? e.length - 1 : M(u) - 1, !0);
      },
      async ArrowDown() {
        let e = await o.items;
        m(u, M(u) === e.length - 1 ? 0 : M(u) + 1, !0);
      },
    };
  function v(e) {
    let t = _[e.key];
UI16 建议层焦点控制和选择回填:Escape关闭内容;Up/Down可打开建议;选择使用getString填value并关闭;focus非空时打开、blur移除keydown并关闭。

chunks/DugrqFmF.mjs · 字符偏移 2983 · 静态源码

格式化上下文 · 第193行起;原始精确片段保留在证据JSON。打开带行号阅读版

function X(r, i) {
  P(i, !0);
  let s = () => N(V, `$text`, g),
    l = () => N(H, `$suggest`, g),
    [g, v] = u(),
    y = S(i, `inputRef`, 15),
    x = S(i, `placeholder`, 3, `Search...`),
    C = S(i, `showSearchContent`, 3, !0),
    T = S(i, `searchContentHeight`, 3, 500),
    D = S(i, `debounceMs`, 3, 300),
    A = O(i, q),
    F = t(!1),
    V = I(i.value ?? ``),
    H = U(V, i.getOptions, D(), Promise.resolve([])),
    W = {
      blur: () => b(() => i.onblur?.()),
      focus: () => b(() => i.onfocus?.()),
      input: (e) => b(() => i.oninput?.(e)),
      select: (e) => b(() => i.onselect?.(e)),
    },
    G = (e) => W.select(e),
    X = (e) => W.input(e),
    re = () => W.focus(),
    Z = () => W.blur();
  async function ie(e) {
UI17 通用请求store兼顾fetch、追加和refetch:fetch置loading清error,成功transformer并记录previousVariables;loadMore基于previousVariables计算新参数并combiner合并;失败保留旧data写error;refetch只在存在previousVariables时执行。

chunks/BSZQCP47.mjs · 字符偏移 1439 · 静态源码

格式化上下文 · 第67行起;原始精确片段保留在证据JSON。打开带行号阅读版

function T(e, n) {
  let r = C(n?.transformer),
    i = w(n?.combiner),
    a = l({ loading: !1, error: null, data: n?.initialData ?? null }),
    o = async (t, n = { fetch }) => {
      a.update((e) => ({ ...e, loading: !0, error: null }));
      try {
        let i = await c({ doc: e, variables: t, load: n });
        return (
          a.update((e) => ({
            ...e,
            loading: !1,
            error: null,
            data: r(i, e.data),
            previousVariables: t,
          })),
          i
        );
      } catch (e) {
        let t = e instanceof Error ? e.message : `An unknown error occurred`;
        return (a.update((e) => ({ ...e, loading: !1, error: t })), null);
      }
    },
    s = async (n, o = { fetch }) => {
      a.update((e) => ({ ...e, loading: !0, error: null }));
UI18 汇率配置在前端展开矩阵:读取currencyConfiguration.baseRates,按名称排序launched/display法币;每源币baseRate除目标baseRate生成rates[source][target];没有新baseRates时保留已有rates或空配置。

chunks/BSZQCP47.mjs · 字符偏移 2790 · 静态源码

格式化上下文 · 第142行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ rates: null, displayFiatCurrencies: [], launchedFiatCurrencies: [] }),
  k = (e, t) => {
    let n = e?.currencyConfiguration;
    if (n?.baseRates?.length) {
      let e = (e, t) => g({ currency: b(e) }, { currency: b(t) }),
        t = n?.launchedFiatCurrencies ?? [];
      t.sort(e);
      let r = n?.displayFiatCurrencies ?? [];
      r.sort(e);
      let i = D(n.baseRates, `currency`),
        a = (e, t) =>
          r.reduce(
            (e, n) => {
              let r = t / i[n].baseRate;
              return { ...e, [n]: r };
            },
            { [e]: 1 },
          );
      return {
        rates: n.baseRates.reduce(
          (e, { baseRate: t, currency: n }) => ({ ...e, [n]: a(n, t) }),
          {},
        ),
        launchedFiatCurrencies: t,
        displayFiatCurrencies: r,

汇率的新鲜度和后端定价不能从矩阵算式推断。

UI19 实际游戏币种与展示视图是独立store:currency、hideZeroBalances、currencyView使用cookie namespace currency;currencyView默认crypto;派生F用x(view,currency)规范化。

chunks/BSZQCP47.mjs · 字符偏移 3353 · 静态源码

格式化上下文 · 第142行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ rates: null, displayFiatCurrencies: [], launchedFiatCurrencies: [] }),
  k = (e, t) => {
    let n = e?.currencyConfiguration;
    if (n?.baseRates?.length) {
      let e = (e, t) => g({ currency: b(e) }, { currency: b(t) }),
        t = n?.launchedFiatCurrencies ?? [];
      t.sort(e);
      let r = n?.displayFiatCurrencies ?? [];
      r.sort(e);
      let i = D(n.baseRates, `currency`),
        a = (e, t) =>
          r.reduce(
            (e, n) => {
              let r = t / i[n].baseRate;
              return { ...e, [n]: r };
            },
            { [e]: 1 },
          );
      return {
        rates: n.baseRates.reduce(
          (e, { baseRate: t, currency: n }) => ({ ...e, [n]: a(n, t) }),
          {},
        ),
        launchedFiatCurrencies: t,
        displayFiatCurrencies: r,
UI20 金额展示转换率作为响应式派生:显示crypto时B=0,否则rates[actual][view]或0;V独立derive actual到usd;H发布可用展示币与fetching/completed。

chunks/BSZQCP47.mjs · 字符偏移 3722 · 静态源码

格式化上下文 · 第142行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ rates: null, displayFiatCurrencies: [], launchedFiatCurrencies: [] }),
  k = (e, t) => {
    let n = e?.currencyConfiguration;
    if (n?.baseRates?.length) {
      let e = (e, t) => g({ currency: b(e) }, { currency: b(t) }),
        t = n?.launchedFiatCurrencies ?? [];
      t.sort(e);
      let r = n?.displayFiatCurrencies ?? [];
      r.sort(e);
      let i = D(n.baseRates, `currency`),
        a = (e, t) =>
          r.reduce(
            (e, n) => {
              let r = t / i[n].baseRate;
              return { ...e, [n]: r };
            },
            { [e]: 1 },
          );
      return {
        rates: n.baseRates.reduce(
          (e, { baseRate: t, currency: n }) => ({ ...e, [n]: a(n, t) }),
          {},
        ),
        launchedFiatCurrencies: t,
        displayFiatCurrencies: r,
UI21 访客与登录用户的展示币偏好分支:J/Y用meta.isAuthenticated:登录采用P用户currencyView;访客采用K默认交换币策略。Y再结合actualCurrency规范化。

chunks/BSZQCP47.mjs · 字符偏移 4220 · 静态源码

格式化上下文 · 第142行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ rates: null, displayFiatCurrencies: [], launchedFiatCurrencies: [] }),
  k = (e, t) => {
    let n = e?.currencyConfiguration;
    if (n?.baseRates?.length) {
      let e = (e, t) => g({ currency: b(e) }, { currency: b(t) }),
        t = n?.launchedFiatCurrencies ?? [];
      t.sort(e);
      let r = n?.displayFiatCurrencies ?? [];
      r.sort(e);
      let i = D(n.baseRates, `currency`),
        a = (e, t) =>
          r.reduce(
            (e, n) => {
              let r = t / i[n].baseRate;
              return { ...e, [n]: r };
            },
            { [e]: 1 },
          );
      return {
        rates: n.baseRates.reduce(
          (e, { baseRate: t, currency: n }) => ({ ...e, [n]: a(n, t) }),
          {},
        ),
        launchedFiatCurrencies: t,
        displayFiatCurrencies: r,
UI22 币种列表搜索与隐藏零余额交互:无搜索时,在非noBalance视图且hideZeroBalances为真,过滤formattedForFilter==0;搜索时忽略零余额过滤,对币种名称与输入去除非字母数字、小写后includes。

chunks/Dv6FGyZG.mjs · 字符偏移 5532 · 静态源码

格式化上下文 · 第290行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Le(c, d) {
  O(d, !0);
  let h = () => E(ee, `$hideZeroBalances`, v),
    g = () => E(I, `$i18n`, v),
    [v, b] = o(),
    S = _(d, `truncateMaxWidth`, 3, `14ch`),
    k = _(d, `variant`, 3, `dropdown`),
    j = _(d, `view`, 3, `default`),
    M = _(d, `currencyView`, 3, `compact`),
    N = _(d, `onSurface`, 3, !1),
    P = _(d, `hideConversion`, 3, !1),
    F = _(d, `displayCurrencyManagement`, 3, !1),
    L = _(d, `displayCurrencySearch`, 3, !0),
    R = t(``),
    z = t(void 0),
    B = (e = ``) => e.toLowerCase().replace(/[^a-z0-9]+/gi, ``),
    V = p(() =>
      d.balances?.filter((e) => {
        if (T(R).trim() === ``)
          return j() !== `noBalance` && h() ? Number(e.formattedForFilter) !== 0 : !0;
        let t = te[e.currency];
        return B(t ?? ``).includes(B(T(R))) ? e : !1;
      }),
    );
  var H = Ie(),
UI23 币种选中后立即关闭选择层:每币按钮调用changeCurrency(currency),然后closeDropdown;只负责选择事件,不在按钮里发余额请求。

chunks/Dv6FGyZG.mjs · 字符偏移 6691 · 静态源码

格式化上下文 · 第290行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Le(c, d) {
  O(d, !0);
  let h = () => E(ee, `$hideZeroBalances`, v),
    g = () => E(I, `$i18n`, v),
    [v, b] = o(),
    S = _(d, `truncateMaxWidth`, 3, `14ch`),
    k = _(d, `variant`, 3, `dropdown`),
    j = _(d, `view`, 3, `default`),
    M = _(d, `currencyView`, 3, `compact`),
    N = _(d, `onSurface`, 3, !1),
    P = _(d, `hideConversion`, 3, !1),
    F = _(d, `displayCurrencyManagement`, 3, !1),
    L = _(d, `displayCurrencySearch`, 3, !0),
    R = t(``),
    z = t(void 0),
    B = (e = ``) => e.toLowerCase().replace(/[^a-z0-9]+/gi, ``),
    V = p(() =>
      d.balances?.filter((e) => {
        if (T(R).trim() === ``)
          return j() !== `noBalance` && h() ? Number(e.formattedForFilter) !== 0 : !0;
        let t = te[e.currency];
        return B(t ?? ``).includes(B(T(R))) ? e : !1;
      }),
    );
  var H = Ie(),
UI24 币种图标延迟加载防止过期图标:由currency+normalised选择图标loader,异步import后只有active且当前loader一致时写图标;cleanup active=false;未就绪显示skeleton。

chunks/CZV1OlKI.mjs · 字符偏移 24777 · 静态源码

格式化上下文 · 第654行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Te(n, s) {
  A(s, !0);
  let c = C(s, Ce),
    u = Se(),
    d = h(() =>
      u && typeof u.preferenceNormalised == `boolean` ? u.preferenceNormalised : s.normalised,
    ),
    g = h(() => be(String(s.currency), J, D(d))),
    _ = h(() => (s.size ? de[s.size] : de.md)),
    v = t(void 0);
  r(() => {
    let e = D(g);
    if (!e) {
      m(v, void 0);
      return;
    }
    let t = !0;
    return (
      e()
        .then((n) => {
          t && D(g) === e && m(v, n.default, !0);
        })
        .catch(() => {
          t && D(g) === e && m(v, void 0);
        }),
UI25 feature flag先读本地缓存再请求单项:以name键保存flag对象;getFeatureFlagConfig缓存命中直接返回;miss单项query成功update;addFeatureFlags用列表reduce覆盖字典;fetchAll取limit50 offset0。

chunks/GK7HiuOi.mjs · 字符偏移 10529 · 静态源码

格式化上下文 · 第5行起;原始精确片段保留在证据JSON。打开带行号阅读版

var i = {
    kind: `Document`,
    definitions: [
      {
        kind: `OperationDefinition`,
        operation: `query`,
        name: { kind: `Name`, value: `GetFeatureFlags` },
        variableDefinitions: [
          {
            kind: `VariableDefinition`,
            variable: { kind: `Variable`, name: { kind: `Name`, value: `limit` } },
            type: { kind: `NamedType`, name: { kind: `Name`, value: `Int` } },
            defaultValue: { kind: `IntValue`, value: `50` },
          },
          {
            kind: `VariableDefinition`,
            variable: { kind: `Variable`, name: { kind: `Name`, value: `offset` } },
            type: { kind: `NamedType`, name: { kind: `Name`, value: `Int` } },
            defaultValue: { kind: `IntValue`, value: `0` },
          },
        ],
        selectionSet: {
          kind: `SelectionSet`,
          selections: [
            {

fetchAll无后续分页和失效策略;返回超过50的全量覆盖不应默认。

UI26 支付能力按全局开关与beta名单选择:fiat orchestrator取parent kycUserInfoResponse.user.id;选择enabled且stakeReadsFromFiatOrchestrator或betaUserIds含用户;payment escalation以enabled或userIds含用户。

chunks/Bx-TE4cQ.mjs · 字符偏移 106 · 静态源码

格式化上下文 · 第4行起;原始精确片段保留在证据JSON。打开带行号阅读版

var r = async (t) => {
    let { kycUserInfoResponse: r } = await t.parent(),
      i = r?.user?.id,
      a = (await n.getFeatureFlagConfig(e.fiat_orchestrator_flag, t))?.config;
    return (a?.enabled && a?.stakeReadsFromFiatOrchestrator) || (i && a?.betaUserIds.includes(i));
  },
  i = async (t) => {
    let { kycUserInfoResponse: r } = await t.parent(),
      i = r?.user?.id,
      a = (await n.getFeatureFlagConfig(e.payment_escalation_flag, t))?.config;
    return !!(a?.enabled || (i && a?.userIds?.includes(i)));
  },
  a = ({ value: e, remoteRolloutFlag: n }) => {
    if (!e) return !1;
    if (n !== void 0) return n;
    try {
      return t.getBooleanFlagSync(`paymentsReleaseSweepsCrypto`, !1).value;
    } catch (t) {
      return (console.error(t), e);
    }
  };
export { r as n, i as r, a as t };
UI27 聊天初始快照与订阅采用就绪门控:fetch清deleted列表与messageList,拉历史消息后reverse,写loading=false再a=true;chatMessages订阅只在a为真时追加;追加保留旧消息最后50后按id去重,并维护user去重集合。

chunks/C_hHBl49.mjs · 字符偏移 29334 · 静态源码

格式化上下文 · 第29行起;原始精确片段保留在证据JSON。打开带行号阅读版

var T = f(!1),
  E = f(`question`),
  he = f(t(v)),
  ge = f(``),
  _e = f(``),
  D = f(``),
  O = f(null),
  k = f(null),
  A = (e, t) => e && e.trim().toLowerCase() === t.trim().toLowerCase(),
  j = (e, n) => {
    let r = new Date(e.createdAt),
      i = e?.data?.__typename === `ChatMessageDataText` ? e.data.message : ``;
    r.getTime() > (t(O)?.getTime() ?? 0) &&
      A(i, t(D)) &&
      e?.user?.id !== n.id &&
      (k.set(e), E.set(`credited`));
  },
  M = e(ne(), 1),
  N = (e) => {
    (0, M.default)(le, e);
  },
  P = (e) => {
    (0, M.default)(ce, e);
  },
  F = new ee(),

可能漏掉加载期间消息;是否由历史覆盖/重连修复未验证。

UI28 聊天删除事件从本地列表剔除:chatMessageDeleted记录id至K并按id过滤messageList。

chunks/C_hHBl49.mjs · 字符偏移 29524 · 静态源码

格式化上下文 · 第29行起;原始精确片段保留在证据JSON。打开带行号阅读版

var T = f(!1),
  E = f(`question`),
  he = f(t(v)),
  ge = f(``),
  _e = f(``),
  D = f(``),
  O = f(null),
  k = f(null),
  A = (e, t) => e && e.trim().toLowerCase() === t.trim().toLowerCase(),
  j = (e, n) => {
    let r = new Date(e.createdAt),
      i = e?.data?.__typename === `ChatMessageDataText` ? e.data.message : ``;
    r.getTime() > (t(O)?.getTime() ?? 0) &&
      A(i, t(D)) &&
      e?.user?.id !== n.id &&
      (k.set(e), E.set(`credited`));
  },
  M = e(ne(), 1),
  N = (e) => {
    (0, M.default)(le, e);
  },
  P = (e) => {
    (0, M.default)(ce, e);
  },
  F = new ee(),
UI29 聊天发送有命令路由、乐观清空与失败回填:trim长度>=1且原文<=160才允许;/开头从command registry匹配并执行;普通消息先清input+loading,再mutation携chatId/message/replyId;GraphQL错误或catch恢复原文;成功清reply、结束loading、上报messageSent。

chunks/C_hHBl49.mjs · 字符偏移 30256 · 静态源码

格式化上下文 · 第29行起;原始精确片段保留在证据JSON。打开带行号阅读版

var T = f(!1),
  E = f(`question`),
  he = f(t(v)),
  ge = f(``),
  _e = f(``),
  D = f(``),
  O = f(null),
  k = f(null),
  A = (e, t) => e && e.trim().toLowerCase() === t.trim().toLowerCase(),
  j = (e, n) => {
    let r = new Date(e.createdAt),
      i = e?.data?.__typename === `ChatMessageDataText` ? e.data.message : ``;
    r.getTime() > (t(O)?.getTime() ?? 0) &&
      A(i, t(D)) &&
      e?.user?.id !== n.id &&
      (k.set(e), E.set(`credited`));
  },
  M = e(ne(), 1),
  N = (e) => {
    (0, M.default)(le, e);
  },
  P = (e) => {
    (0, M.default)(ce, e);
  },
  F = new ee(),

这是源码协议分析,没有发送任何消息。

UI30 聊天命令展示过滤角色与隐藏项:command列表按!admin||hasRole过滤;匹配cmd小写contains;r决定是否包含hidden命令。

chunks/C_hHBl49.mjs · 字符偏移 27989 · 静态源码

格式化上下文 · 第29行起;原始精确片段保留在证据JSON。打开带行号阅读版

var T = f(!1),
  E = f(`question`),
  he = f(t(v)),
  ge = f(``),
  _e = f(``),
  D = f(``),
  O = f(null),
  k = f(null),
  A = (e, t) => e && e.trim().toLowerCase() === t.trim().toLowerCase(),
  j = (e, n) => {
    let r = new Date(e.createdAt),
      i = e?.data?.__typename === `ChatMessageDataText` ? e.data.message : ``;
    r.getTime() > (t(O)?.getTime() ?? 0) &&
      A(i, t(D)) &&
      e?.user?.id !== n.id &&
      (k.set(e), E.set(`credited`));
  },
  M = e(ne(), 1),
  N = (e) => {
    (0, M.default)(le, e);
  },
  P = (e) => {
    (0, M.default)(ce, e);
  },
  F = new ee(),

客户端隐藏命令不证明服务端授权规则。

UI31 聊天频道选择含本地偏好和国家兜底:userPreferredChat来自localStorage;频道选择按当前类型前缀、用户偏好或locale匹配;国家IN优先hi;否则英文fallback,再取列表第一个。

chunks/C_hHBl49.mjs · 字符偏移 31059 · 静态源码

格式化上下文 · 第29行起;原始精确片段保留在证据JSON。打开带行号阅读版

var T = f(!1),
  E = f(`question`),
  he = f(t(v)),
  ge = f(``),
  _e = f(``),
  D = f(``),
  O = f(null),
  k = f(null),
  A = (e, t) => e && e.trim().toLowerCase() === t.trim().toLowerCase(),
  j = (e, n) => {
    let r = new Date(e.createdAt),
      i = e?.data?.__typename === `ChatMessageDataText` ? e.data.message : ``;
    r.getTime() > (t(O)?.getTime() ?? 0) &&
      A(i, t(D)) &&
      e?.user?.id !== n.id &&
      (k.set(e), E.set(`credited`));
  },
  M = e(ne(), 1),
  N = (e) => {
    (0, M.default)(le, e);
  },
  P = (e) => {
    (0, M.default)(ce, e);
  },
  F = new ee(),
UI32 聊天限速反馈启动频道倒计时:消息错误Please slow down时initialise(chatId);按publicChats.messageInterval建立每频道剩余值,已有倒计时不重启,递归延时递减直到0。

chunks/C_hHBl49.mjs · 字符偏移 31306 · 静态源码

格式化上下文 · 第29行起;原始精确片段保留在证据JSON。打开带行号阅读版

var T = f(!1),
  E = f(`question`),
  he = f(t(v)),
  ge = f(``),
  _e = f(``),
  D = f(``),
  O = f(null),
  k = f(null),
  A = (e, t) => e && e.trim().toLowerCase() === t.trim().toLowerCase(),
  j = (e, n) => {
    let r = new Date(e.createdAt),
      i = e?.data?.__typename === `ChatMessageDataText` ? e.data.message : ``;
    r.getTime() > (t(O)?.getTime() ?? 0) &&
      A(i, t(D)) &&
      e?.user?.id !== n.id &&
      (k.set(e), E.set(`credited`));
  },
  M = e(ne(), 1),
  N = (e) => {
    (0, M.default)(le, e);
  },
  P = (e) => {
    (0, M.default)(ce, e);
  },
  F = new ee(),

递减常量b精确单位未单独追踪,未报告固定秒数。

UI33 语言切换更新store并执行路径导航:updateLanguage先set locale,然后用o(pathname,newLocale)生成新路径并赋window.location.pathname;服务端环境不导航。

chunks/C_ugM1im.mjs · 字符偏移 23684 · 静态源码

格式化上下文 · 第1203行起;原始精确片段保留在证据JSON。打开带行号阅读版

var Z = (e) => {
    let t = X({ locale: e.locale, messages: { [e.locale]: e.catalog }, locales: i });
    return (
      t.setMessagesCompiler(A),
      t.activate(e.locale),
      Object.assign(t, {
        message: (e) => {
          let n = e && typeof e == `string` ? e : e?.id;
          return t.messages[n];
        },
      })
    );
  },
  Q = (() => {
    let e = a(r, n.defaultLanguage);
    return {
      init: (t) => {
        e.set(t);
      },
      updateLanguage: (t) => {
        if ((e.set(t), typeof window > `u`)) return;
        let n = o(window.location.pathname, t);
        window.location.pathname = n;
      },
      locale: e,
UI34 Lingui运行时有缺失文案回退:翻译前要求激活locale;消息id可带values/message;缺失触发missing事件,回退显式message或id;编译器把raw字符串转成ICU结构;number/date用Intl缓存格式化。

chunks/C_ugM1im.mjs · 字符偏移 22364 · 静态源码

_(e,t,n){if(!this.locale)throw Error(`Lingui: Attempted to call a translation function without setting a locale.
Make sure to call \`i18n.activate(locale)\` before using Lingui functions.
This issue may also occur due to a race condition in your initialization logic.`);let r=n?.message;e||=``,j(e)||(t=e.values||t,r=e.message,e=e.id);let i=this.messages[e],a=i===void 0,o=this._missing;if(o&&a)return M(o)?o(this._locale,e):o;a&&this.emit(`missing`,{id:e,locale:this._locale});let s=i||r||e;return j(s)&&(this._messageCompiler?s=this._messageCompiler(s):console.warn(`Uncompiled message detected! Message:

> ${s}

That means you use raw catalog or your catalog doesn't have a translation for the message and fallback was used.
ICU features such as interpolation and plurals will not work properly for that message. 

Please compile your catalog first. 
`)),j(s)&&H.test(s)?U(s):j(s)?s:q(s,this._locale,this._locales)(t,n?.formats)}t=this._.bind(this);date(e,t){return I(this._locales||this._locale,e,t)}number(e,t){return R(this._locales||this._locale,e,t)}};function X(e={}){return new Y(e)}X();var Z=e=>{let t=X({locale:e.locale,messages:{[e.locale]:e.catalog},locales:i});return t.setMessagesCompiler(A),t.activate(e.locale),Object.ass
UI35 OAuth弹窗关闭会清理订阅及轮询:每100ms检测窗口closed或结果G已完成,结束interval;te销毁阶段清interval、close窗口、X取消K并清openOauthSubscriptions。

chunks/DT98r2cN.mjs · 字符偏移 16116 · 静态源码

格式化上下文 · 第666行起;原始精确片段保留在证据JSON。打开带行号阅读版

function L(v, w) {
  let E = ne();
  ae(w, !0);
  let D = () => S(A, `$openOauthSubscriptions`, F),
    P = () => S(de, `$i18n`, F),
    [F, L] = l(),
    R = _(w, `onlyShowDefaultOauth`, 7, !1),
    Ne = _(w, `showProviderToggle`, 3, !1),
    z = _(w, `primaryProvider`, 3, void 0),
    Pe = _(w, `buttonText`, 3, `signInWith`),
    B = _(w, `useLargeButtons`, 3, !1),
    V = _(w, `useMediumButtons`, 3, !1),
    H = _(w, `size`, 3, void 0),
    Fe = _(w, `showProvider`, 3, !1),
    Ie = _(w, `stretch`, 3, !1),
    Le = _(w, `oauthProviders`, 3, void 0),
    Re = _(w, `afterDefaultProvider`, 3, void 0),
    ze = _(w, `disabled`, 3, !1),
    Be = _(w, `id`, 3, E),
    U = m(() => (Le()?.length ? Le() : ke)),
    W,
    G,
    K,
    q = t(!1),
    J = !1,
UI36 Google登录可切redirect模式,失败回退popup:Xe生成codeChallenge请求startOauthRedirect,returnTo带当前path/search/hash;成功导航url;失败clear并false。Qe仅Google且platformReleaseOauthRedirect开启先尝试Xe,否则Ye订阅popup。

chunks/DT98r2cN.mjs · 字符偏移 17128 · 静态源码

格式化上下文 · 第666行起;原始精确片段保留在证据JSON。打开带行号阅读版

function L(v, w) {
  let E = ne();
  ae(w, !0);
  let D = () => S(A, `$openOauthSubscriptions`, F),
    P = () => S(de, `$i18n`, F),
    [F, L] = l(),
    R = _(w, `onlyShowDefaultOauth`, 7, !1),
    Ne = _(w, `showProviderToggle`, 3, !1),
    z = _(w, `primaryProvider`, 3, void 0),
    Pe = _(w, `buttonText`, 3, `signInWith`),
    B = _(w, `useLargeButtons`, 3, !1),
    V = _(w, `useMediumButtons`, 3, !1),
    H = _(w, `size`, 3, void 0),
    Fe = _(w, `showProvider`, 3, !1),
    Ie = _(w, `stretch`, 3, !1),
    Le = _(w, `oauthProviders`, 3, void 0),
    Re = _(w, `afterDefaultProvider`, 3, void 0),
    ze = _(w, `disabled`, 3, !1),
    Be = _(w, `id`, 3, E),
    U = m(() => (Le()?.length ? Le() : ke)),
    W,
    G,
    K,
    q = t(!1),
    J = !1,

PKCE verifier生成/持久化实现依赖未展开;不宣称验证完整安全性。

UI37 地址表单恢复仅接受字符串字段:从保存值按initialValues字段key筛选string,并合并默认;display address优先address,否则拼streetNumber/street,截断255。

chunks/DnhHZlp1.mjs · 字符偏移 2586 · 静态源码

格式化上下文 · 第5行起;原始精确片段保留在证据JSON。打开带行号阅读版

var r = (function (e) {
    return (
      (e.ADDRESS = `address`),
      (e.STREET = `street`),
      (e.APARTMENT = `apartment`),
      (e.CITY = `city`),
      (e.PROVINCE = `province`),
      (e.COUNTRY = `country`),
      (e.POSTAL_CODE = `postalCode`),
      (e.STREET_NUMBER = `streetNumber`),
      (e.SUBURB = `suburb`),
      e
    );
  })({}),
  i = {
    addressHeader: { id: `-sfnBi` },
    addressDescription: { id: `20r5H1` },
    addressPlaceholder: { id: `SFRpt3` },
    addressRequired: { id: `xLj1y0` },
    countryLabel: { id: `JNCzPW` },
    countryRequired: { id: `UbPlKe` },
    streetLabel: { id: `rDhHln` },
    streetPlaceholder: { id: `rJyN47` },
    streetRequired: { id: `6xb7Xp` },
    houseLabel: { id: `StVmyZ` },
UI38 推广指纹仅在配置齐全且flag开启时初始化:publicApiKey与region存在,visitor_campaign_attribution_flag.config.enabled成立才创建FingerprintAgent/start并get visitorId;所有异常返回undefined。

chunks/DnJrFyWP.mjs · 字符偏移 1867 · 静态源码

格式化上下文 · 第61行起;原始精确片段保留在证据JSON。打开带行号阅读版

var v = 1e-8,
  y = g.default.namespace(`affiliate`),
  b,
  x = () => {
    if (b) return b;
    let e = a?.affiliate?.fingerprint?.publicApiKey,
      t = a?.affiliate?.fingerprint?.region,
      r = a?.affiliate?.fingerprint?.endpoints?.length ? a.affiliate.fingerprint.endpoints : void 0;
    return !e || !t
      ? Promise.resolve(void 0)
      : ((b = n(
          async () => {
            let { createFingerprintAgent: e } = await import(`./D4t6yLWZ.mjs`);
            return { createFingerprintAgent: e };
          },
          __vite__mapDeps([0, 1]),
          import.meta.url,
        )
          .then(({ createFingerprintAgent: n }) =>
            n({ publicApiKey: e }).start({ region: t, endpoints: r }),
          )
          .catch(() => void 0)),
        b);
  },
  S = async () => {

这里只确认调用条件;实际同意流程需analytics/cookie管理上下文佐证。

UI39 全局配置汇集不同产品能力:Config构造将currency/dateTime/userPreferences/footer/SEO/i18n/analytics/observability/onboarding/VIP/casino/integrations/cookieManagement/featureFlags等赋到对象,再逐字段处理$(...)。

chunks/DiYNMAEe.mjs · 字符偏移 13431 · 静态源码

格式化上下文 · 第418行起;原始精确片段保留在证据JSON。打开带行号阅读版

var ie = new (class e {
  canonicalURL;
  graphql;
  emails;
  supportedLanguages;
  defaultLanguage;
  englishFlag;
  defaultExchangeCurrency;
  defaultPlayableCurrency;
  defaultTransactableCurrency;
  typesOfBetRacesEnabled;
  transactableCurrencies;
  playableCurrencies;
  displayCryptoInFiatCurrencies;
  acpCoinToggleCurrencies;
  helpCenter;
  mirrors;
  baseVipRankEnabled;
  vip;
  defaultAutoCompleteValue;
  responsibleGambling;
  userScreening;
  isFixedSingleCurrencyMarket;
  locationTracking;
  appReviewTokens;

这里只能确认字段和处理调用;没有完整追踪$的冻结或校验语义。

SUP01 根layout明确输出Svelte 5 console标识;组件使用编译后的响应式runtime调用。能确认大版本宣称,不能得到准确Svelte patch。

nodes/0.CR0Lrtr3.mjs · 字符偏移 13917 · 静态源码

格式化上下文 · 第708行起;原始精确片段保留在证据JSON。打开带行号阅读版

function dt(e, n) {
  C(n, !0);
  let r = () => S(ne, `$page`, a),
    [a, p] = c();
  (Ie(ot()), console.info(`%c~~ Svelte 5 ~~`, `color: fuchsia; font-size: 20px;`));
  let m = h(() => n.data.authResponse?.user?.id);
  (Ce(),
    Ke(),
    n.data.session?.isAuthenticated && n.data.authResponse?.user?.id && Ee(),
    _(async () => {
      Te();
    }),
    Se());
  var v = ut();
  l(`12qhfyh`, (e) => {
    var n = t(),
      i = u(n),
      a = (e) => {
        var t = st();
        f(e, t);
      },
      o = h(() => Fe(r().params.lang));
    (s(i, (e) => {
      x(o) && e(a);
    }),

静态打包证据;未执行浏览器或服务端操作。

SUP02 入口导出dictionary/nodes/root/hooks/server_loads并以node数组动态import挂载分层页面,这是SvelteKit式客户端生产结构。

entry/app.Q5XUkswp.mjs · 字符偏移 252707 · 静态源码

格式化上下文 · 第6868行起;原始精确片段保留在证据JSON。打开带行号阅读版

export {
  xt as decode,
  $ as decoders,
  vt as dictionary,
  yt as encoders,
  St as get_error_template,
  bt as hash,
  Q as hooks,
  dt as matchers,
  gt as nodes,
  ht as root,
  _t as server_loads,
};

静态打包证据;未执行浏览器或服务端操作。

SUP03 Vite helper生成modulepreload和stylesheet,去重URL并继承CSP nonce;失败发vite:preloadError。

chunks/uBIymjUX.mjs · 字符偏移 689 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

var e = function (e, t) {
    return new URL(e, t).href;
  },
  t = {},
  n = function (n, r, i) {
    let a = Promise.resolve();
    if (r && r.length > 0) {
      let n = document.getElementsByTagName(`link`),
        o = document.querySelector(`meta[property=csp-nonce]`),
        s = o?.nonce || o?.getAttribute(`nonce`);
      function c(e) {
        return Promise.all(
          e.map((e) =>
            Promise.resolve(e).then(
              (e) => ({ status: `fulfilled`, value: e }),
              (e) => ({ status: `rejected`, reason: e }),
            ),
          ),
        );
      }
      function l(e) {
        return import.meta.resolve ? import.meta.resolve(e) : new URL(e, import.meta.url).href;
      }
      a = c(
        r

静态打包证据;未执行浏览器或服务端操作。

SUP04 全局CSS含@layer properties/theme/base/edge,components/utilities及--tw-*;与Tailwind4输出相容但无准确版本标记。

assets/0.CBZv068J.css · 字符偏移 2317 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

:root {
  color: var(--color-grey-200);
  --shadows-sm: 0 1px 3px 0 #0003, 0 1px 2px 0 #0000001f;
  --shadows-md: 0 4px 6px -1px #1b171733, 0 2px 4px -1px #0000001f;
  --shadows-lg: 0 10px 15px -3px #0003, 0 4px 6px -2px #0000001a;
  --shadows-xl: 0 20px 25px -5px #0003, 0 10px 10px -5px #00000014;
  --shadows-2xl: 0 25px 50px -12px #0006;
  --shadows-inner: inset 0 2px 4px 0 #0003;
  --shadow-inset: inset 0 1px #ffffff0a;
  --btn-shadow: var(--shadows-sm), var(--shadow-inset);
  --shadow-button-sm: 0rem 0.0625rem 0.1875rem #0003, 0rem 0.0625rem 0.125rem #0000001f;
  --border-thin: 0.0625rem;
  --border-light: 0.125rem;
  --border-medium: 0.25rem;
  --border-radius-none: 0;
  --border-radius-sm: 0.125rem;
  --border-radius-base: 0.25rem;
  --border-radius-md: 0.5rem;
  --border-radius-lg: 4rem;
  --border-radius-0-15: 0.15rem;
  --input-color: var(--color-white);
  --input-background: var(--color-grey-700);
  --input-border: var(--color-grey-400);
  --input-placeholder: #566671;
  --input-hover-color: var(--color-white);

静态打包证据;未执行浏览器或服务端操作。

SUP05 状态库有xstate.start/stop/raise/send/cancel/assign内部事件,业务machine调用actions/invoke/parallel;是XState实现边界,不将整个chunk当业务。

chunks/ikB3MhCy.mjs · 字符偏移 145 · 静态源码

格式化上下文 · 第18行起;原始精确片段保留在证据JSON。打开带行号阅读版

(function (e) {
  ((e.Start = `xstate.start`),
    (e.Stop = `xstate.stop`),
    (e.Raise = `xstate.raise`),
    (e.Send = `xstate.send`),
    (e.Cancel = `xstate.cancel`),
    (e.NullEvent = ``),
    (e.Assign = `xstate.assign`),
    (e.After = `xstate.after`),
    (e.DoneState = `done.state`),
    (e.DoneInvoke = `done.invoke`),
    (e.Log = `xstate.log`),
    (e.Init = `xstate.init`),
    (e.Invoke = `xstate.invoke`),
    (e.ErrorExecution = `error.execution`),
    (e.ErrorCommunication = `error.communication`),
    (e.ErrorPlatform = `error.platform`),
    (e.ErrorCustom = `xstate.error`),
    (e.Update = `xstate.update`),
    (e.Pure = `xstate.pure`),
    (e.Choose = `xstate.choose`));
})((m ||= {}));
var h;
(function (e) {
  ((e.Parent = `#_parent`), (e.Internal = `#_internal`));

静态打包证据;未执行浏览器或服务端操作。

SUP06 Howler/Howl完整音频引擎打包于B5sUBXej;同文件尾部才是业务settings缓存包装。

chunks/B5sUBXej.mjs · 字符偏移 26522 · 静态源码

格式化上下文 · 第5行起;原始精确片段保留在证据JSON。打开带行号阅读版

var a = e((e) => {
    ((function () {
      var t = function () {
        this.init();
      };
      t.prototype = {
        init: function () {
          var e = this || n;
          return (
            (e._counter = 1e3),
            (e._html5AudioPool = []),
            (e.html5PoolSize = 10),
            (e._codecs = {}),
            (e._howls = []),
            (e._muted = !1),
            (e._volume = 1),
            (e._canPlayEvent = `canplaythrough`),
            (e._navigator = typeof window < `u` && window.navigator ? window.navigator : null),
            (e.masterGain = null),
            (e.noAudio = !1),
            (e.usingWebAudio = !0),
            (e.autoSuspend = !0),
            (e.ctx = null),
            (e.autoUnlock = !0),
            e._setup(),

静态打包证据;未执行浏览器或服务端操作。

SUP07 声音业务wrapper用Howl(src)并订阅per-game soundsVolume/soundsEnabled,可fade-in/fade-out。

chunks/Q7NAzzxl.mjs · 字符偏移 300 · 静态源码

格式化上下文 · 第4行起;原始精确片段保留在证据JSON。打开带行号阅读版

var r = t(),
  i = (e, t, n = 1) => {
    e.volume(0);
    let r = e.play();
    return (typeof r == `number` && e.fade(0, n, t, r), r);
  },
  a = (e, t, n) => {
    let r = typeof n == `number` ? e.volume(n) : e.volume();
    (e.fade(r, 0, t, n),
      setTimeout(() => {
        e.stop(n);
      }, t));
  },
  o = (t, i, a = {}) => {
    let o = n(t),
      s = new r.Howl({
        src: Array.isArray(i) ? i : [i],
        volume: e(o.soundsVolume),
        mute: !e(o.soundsEnabled),
        ...a,
      });
    return (
      o.soundsVolume.subscribe((e) => {
        s.volume(e);
      }),

静态打包证据;未执行浏览器或服务端操作。

SUP08 Datadog SDK包含日志采样session与HTTP/FETCH错误监听;此模块是观测SDK,不能把内部xhr错误码当Stake业务API。

chunks/CM5G2D07.mjs · 字符偏移 5123 · 静态源码

格式化上下文 · 第317行起;原始精确片段保留在证据JSON。打开带行号阅读版

function ft(e, t) {
  if (!e.forwardErrorsToLogs) return { stop: x };
  let n = (C ? new Se() : Qe(e)).subscribe((e) => {
      e.state === `complete` && a(E.XHR, e);
    }),
    r = j({ responseBodyAction: (e) => (i(e) ? 2 : 0) }).subscribe((e) => {
      e.state === `resolve` && a(E.FETCH, e);
    });
  function i(e) {
    return !l(e.url) && (pt(e) || ae(e.status));
  }
  function a(n, r) {
    if (!i(r)) return;
    let a = `error` in r && r.error ? Te(Ze(r.error)) : r.responseBody || `Failed to load`,
      o = { isAborted: r.isAborted, handlingStack: r.handlingStack };
    t.notify(0, {
      rawLogsEvent: {
        message: `${mt(n)} error ${r.method} ${r.url}`,
        date: r.startClocks.timeStamp,
        error: { stack: s(a, e.requestErrorResponseLengthLimit, `...`), handling: void 0 },
        http: { method: r.method, status_code: r.status, url: r.url },
        status: F.error,
        origin: A.NETWORK,
      },
      domainContext: o,

静态打包证据;未执行浏览器或服务端操作。

SUP09 CPdaYJXM包含Datadog官方troubleshooting地址和监控帮助常量,是SDK边界的直接标识。

chunks/CPdaYJXM.mjs · 字符偏移 272 · 静态源码

格式化上下文 · 第7行起;原始精确片段保留在证据JSON。打开带行号阅读版

var r = `Datadog Browser SDK:`,
  i = {
    debug: n.debug.bind(t, r),
    log: n.log.bind(t, r),
    info: n.info.bind(t, r),
    warn: n.warn.bind(t, r),
    error: n.error.bind(t, r),
  },
  a = `https://docs.datadoghq.com`,
  o = `${a}/real_user_monitoring/browser/troubleshooting`,
  s = `More details:`;
function c(e, t) {
  return (...n) => {
    try {
      return e(...n);
    } catch (e) {
      i.error(t, e);
    }
  };
}
function l(e) {
  return e !== 0 && Math.random() * 100 <= e;
}
function u(e, t) {
  return +e.toFixed(t);

静态打包证据;未执行浏览器或服务端操作。

SUP10 VabjRqPe包含Lodash hash实现内置sentinel;须按函数作用区分工具库和下游验证接口,不能整个chunk称自研业务。

chunks/VabjRqPe.mjs · 字符偏移 6106 · 静态源码

格式化上下文 · 第73行起;原始精确片段保留在证据JSON。打开带行号阅读版

var m = {
    default: "${path} is invalid",
    required: "${path} is a required field",
    oneOf: "${path} must be one of the following values: ${values}",
    notOneOf: "${path} must not be one of the following values: ${values}",
    notType: ({ path: e, type: t, value: n, originalValue: r }) => {
      let i = r != null && r !== n,
        a =
          `${e} must be a \`${t}\` type, but the final value was: \`${p(n, !0)}\`` +
          (i ? ` (cast from the value \`${p(r, !0)}\`).` : `.`);
      return (
        n === null &&
          (a +=
            '\n If "null" is intended as an empty value be sure to mark the schema as `.nullable()`'),
        a
      );
    },
    defined: "${path} must be defined",
  },
  h = {
    length: "${path} must be exactly ${length} characters",
    min: "${path} must be at least ${min} characters",
    max: "${path} must be at most ${max} characters",
    matches: '${path} must match the following: "${regex}"',
    email: "${path} must be a valid email",

静态打包证据;未执行浏览器或服务端操作。

SUP11 设计tokens以Edge semantic层映射slateNavy调色板,并保留旧grey alias;背景lowest/default/highest分别900/850/800。

assets/0.CBZv068J.css · 字符偏移 19519 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

:root {
  color: var(--color-grey-200);
  --shadows-sm: 0 1px 3px 0 #0003, 0 1px 2px 0 #0000001f;
  --shadows-md: 0 4px 6px -1px #1b171733, 0 2px 4px -1px #0000001f;
  --shadows-lg: 0 10px 15px -3px #0003, 0 4px 6px -2px #0000001a;
  --shadows-xl: 0 20px 25px -5px #0003, 0 10px 10px -5px #00000014;
  --shadows-2xl: 0 25px 50px -12px #0006;
  --shadows-inner: inset 0 2px 4px 0 #0003;
  --shadow-inset: inset 0 1px #ffffff0a;
  --btn-shadow: var(--shadows-sm), var(--shadow-inset);
  --shadow-button-sm: 0rem 0.0625rem 0.1875rem #0003, 0rem 0.0625rem 0.125rem #0000001f;
  --border-thin: 0.0625rem;
  --border-light: 0.125rem;
  --border-medium: 0.25rem;
  --border-radius-none: 0;
  --border-radius-sm: 0.125rem;
  --border-radius-base: 0.25rem;
  --border-radius-md: 0.5rem;
  --border-radius-lg: 4rem;
  --border-radius-0-15: 0.15rem;
  --input-color: var(--color-white);
  --input-background: var(--color-grey-700);
  --input-border: var(--color-grey-400);
  --input-placeholder: #566671;
  --input-hover-color: var(--color-white);

静态打包证据;未执行浏览器或服务端操作。

SUP12 排版regular字体为proxima-nova系统fallback,technical为JetBrains Mono;全局另有JetBrains Mono的font-face woff2。

assets/0.CBZv068J.css · 字符偏移 31760 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

:root {
  color: var(--color-grey-200);
  --shadows-sm: 0 1px 3px 0 #0003, 0 1px 2px 0 #0000001f;
  --shadows-md: 0 4px 6px -1px #1b171733, 0 2px 4px -1px #0000001f;
  --shadows-lg: 0 10px 15px -3px #0003, 0 4px 6px -2px #0000001a;
  --shadows-xl: 0 20px 25px -5px #0003, 0 10px 10px -5px #00000014;
  --shadows-2xl: 0 25px 50px -12px #0006;
  --shadows-inner: inset 0 2px 4px 0 #0003;
  --shadow-inset: inset 0 1px #ffffff0a;
  --btn-shadow: var(--shadows-sm), var(--shadow-inset);
  --shadow-button-sm: 0rem 0.0625rem 0.1875rem #0003, 0rem 0.0625rem 0.125rem #0000001f;
  --border-thin: 0.0625rem;
  --border-light: 0.125rem;
  --border-medium: 0.25rem;
  --border-radius-none: 0;
  --border-radius-sm: 0.125rem;
  --border-radius-base: 0.25rem;
  --border-radius-md: 0.5rem;
  --border-radius-lg: 4rem;
  --border-radius-0-15: 0.15rem;
  --input-color: var(--color-white);
  --input-background: var(--color-grey-700);
  --input-border: var(--color-grey-400);
  --input-placeholder: #566671;
  --input-hover-color: var(--color-white);

静态打包证据;未执行浏览器或服务端操作。

SUP13 间距tokens通过edge-scale像素阶梯映射;radius sm=4/md=8/full=999。header60px、mobilefooter68px和safe-area/PWA变量支持应用壳适配。

assets/0.CBZv068J.css · 字符偏移 1647 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

:root {
  color: var(--color-grey-200);
  --shadows-sm: 0 1px 3px 0 #0003, 0 1px 2px 0 #0000001f;
  --shadows-md: 0 4px 6px -1px #1b171733, 0 2px 4px -1px #0000001f;
  --shadows-lg: 0 10px 15px -3px #0003, 0 4px 6px -2px #0000001a;
  --shadows-xl: 0 20px 25px -5px #0003, 0 10px 10px -5px #00000014;
  --shadows-2xl: 0 25px 50px -12px #0006;
  --shadows-inner: inset 0 2px 4px 0 #0003;
  --shadow-inset: inset 0 1px #ffffff0a;
  --btn-shadow: var(--shadows-sm), var(--shadow-inset);
  --shadow-button-sm: 0rem 0.0625rem 0.1875rem #0003, 0rem 0.0625rem 0.125rem #0000001f;
  --border-thin: 0.0625rem;
  --border-light: 0.125rem;
  --border-medium: 0.25rem;
  --border-radius-none: 0;
  --border-radius-sm: 0.125rem;
  --border-radius-base: 0.25rem;
  --border-radius-md: 0.5rem;
  --border-radius-lg: 4rem;
  --border-radius-0-15: 0.15rem;
  --input-color: var(--color-white);
  --input-background: var(--color-grey-700);
  --input-border: var(--color-grey-400);
  --input-placeholder: #566671;
  --input-hover-color: var(--color-white);

静态打包证据;未执行浏览器或服务端操作。

SUP14 应用壳满高flex,767px以下scrollable预留移动navigation;coarse/no-hover移动landscape移除该padding。

assets/2.B7tJu5U8.css · 字符偏移 14948 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

hr.svelte-1wsv6ob {
  background: var(--edge-color-surface-fg-decorative);
  width: var(--edge-border-width-default);
  height: 100%;
}
.minimized-tab.svelte-1aea3er {
  background: var(--edge-color-surface-bg-overlay);
  pointer-events: auto;
  color: var(--edge-color-surface-fg-default);
  margin-right: calc(var(--spacing-xxs) * -1);
  display: flex;
  position: relative;
}
.minimized-tab.svelte-1aea3er:last-child {
  border-top-left-radius: var(--edge-radius-md);
}
.title.svelte-1aea3er {
  align-items: center;
  gap: var(--spacing-md);
  padding: var(--spacing-none) var(--spacing-lg);
  display: flex;
  overflow: auto;
}
.title.svelte-1aea3er span {
  display: inline-block;

静态打包证据;未执行浏览器或服务端操作。

SUP15 移动底栏四等分grid固定bottom,768px以上隐藏;active项顶部60%宽指示条。

assets/2.B7tJu5U8.css · 字符偏移 11917 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

hr.svelte-1wsv6ob {
  background: var(--edge-color-surface-fg-decorative);
  width: var(--edge-border-width-default);
  height: 100%;
}
.minimized-tab.svelte-1aea3er {
  background: var(--edge-color-surface-bg-overlay);
  pointer-events: auto;
  color: var(--edge-color-surface-fg-default);
  margin-right: calc(var(--spacing-xxs) * -1);
  display: flex;
  position: relative;
}
.minimized-tab.svelte-1aea3er:last-child {
  border-top-left-radius: var(--edge-radius-md);
}
.title.svelte-1aea3er {
  align-items: center;
  gap: var(--spacing-md);
  padding: var(--spacing-none) var(--spacing-lg);
  display: flex;
  overflow: auto;
}
.title.svelte-1aea3er span {
  display: inline-block;

静态打包证据;未执行浏览器或服务端操作。

SUP16 GameCard在hover设备上移4%并显示右下hover按钮,无hover设备依赖.clicked显示;封面用134.146% padding-top定比例。

assets/GameCard.WR-lRCSJ.css · 字符偏移 879 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

.game-info-wrap.svelte-1o5l7az {
  z-index: 1;
  text-transform: capitalize;
  color: var(--color-white);
  justify-content: space-between;
  align-items: center;
  width: 100%;
  display: flex;
  overflow: hidden;
}
.game-info-wrap.horizontal.svelte-1o5l7az {
  flex-direction: column;
  justify-content: end;
  align-items: flex-start;
}
.wrap-icon.svelte-1o5l7az {
  font-size: var(--edge-scale-32);
  color: var(--color-white);
  z-index: 1;
  margin-bottom: var(--spacing-xl);
  justify-content: center;
  align-items: center;
  display: flex;
}
.wrap-icon.horizontal.svelte-1o5l7az {

静态打包证据;未执行浏览器或服务端操作。

SUP17 Search flex外壳内有透明input和min6rem、高3rem的selector;focus-within改变边框。此CSS不提供debounce/API执行证据。

assets/Search.CLbiuBqh.css · 字符偏移 4194 · 静态源码

.search-selector-wrap.svelte-113ai4d{color:var(--color-grey-200);border-right:var(--edge-border-width-default) solid var(--edge-color-surface-fg-decorative);height:3rem;margin-right:var(--spacing-lg);align-items:center;gap:var(--spacing-md);max-width:100%;overflow:unset;-webkit-user-select:none;user-select:none;width:fit-content;min-width:6rem;display:flex}.search-selector-wrap.svelte-113ai4d:hover{color:var(--color-grey-100)}

静态打包证据;未执行浏览器或服务端操作。

SUP18 input支持前后图标、buttons/password/date;invalid/disabled/readonly/focus分支和:has按钮拼接圆角。

assets/input.CfD1PnkE.css · 字符偏移 2448 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

.input-error.svelte-qto0ce {
  padding: var(--spacing-xs) var(--spacing-none);
  color: var(--edge-color-surface-feedback-fg-critical);
  align-items: center;
  display: flex;
}
.input-error.svelte-qto0ce > * + * {
  margin-left: var(--spacing-xs);
}
.input-error.svelte-qto0ce > .svg-icon {
  font-size: var(--font-size-lg);
}
.indicator.svelte-2vtt3n {
  background: var(--edge-color-surface-bg-sunken);
  border-radius: var(--edge-radius-sm);
  width: 1.5rem;
  height: 1.5rem;
  transition: var(--input-transition);
  box-shadow: var(--input-box-shadow);
  cursor: pointer;
  border: var(--edge-border-width-default) solid var(--edge-color-surface-fg-nontext);
  background-position: 50%;
  background-repeat: no-repeat;
  outline: 0;
  flex-shrink: 0;

静态打包证据;未执行浏览器或服务端操作。

SUP19 GameFairness CSS为游戏控制侧栏提供300px desktop宽度及stacked分支、可滚动内容和sticky上下区域;文件名不能代表仅公平性功能。

assets/GameFairness.Xkwu9hKd.css · 字符偏移 0 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

.game-sidebar.svelte-wcee0x {
  background: var(--edge-color-surface-bg-highest);
  padding: var(--spacing-lg);
  flex-direction: column;
  min-width: 300px;
  display: flex;
  overflow-x: visible;
}
.game-sidebar.svelte-wcee0x:not(.stacked) {
  border-top-left-radius: var(--game-frame-radius);
  border-bottom-left-radius: var(--game-frame-radius);
  width: 300px;
  top: 0;
  bottom: 0;
  right: 0;
}
.game-sidebar.stacked.svelte-wcee0x {
  gap: var(--spacing-lg);
  border-bottom-left-radius: var(--game-frame-radius);
  border-bottom-right-radius: var(--game-frame-radius);
}
.scrollable-content.svelte-wcee0x {
  gap: var(--spacing-lg);
  flex-direction: column;
  min-height: 0;

静态打包证据;未执行浏览器或服务端操作。

SUP20 GameFooter flex两端排布,original与third-party padding不同;draggable游戏禁止theater-mode/mini-player两个入口的显示。

assets/GameFooter.ClumSVaG.css · 字符偏移 237 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

.volume.svelte-fm0t8z {
  padding: var(--spacing-md) var(--spacing-lg);
  gap: var(--spacing-md);
  display: flex;
}
.volume.svelte-fm0t8z > :first-child {
  padding: var(--spacing-none);
}
.volume.svelte-fm0t8z > :last-child {
  --slider-max-width: none;
  flex: 1;
  width: 0;
}
.draggable .theater-mode.svelte-a8mqxw,
.draggable .mini-player.svelte-31plvk {
  display: none;
}
.game-footer.svelte-18h3pyu {
  height: var(--game-footer-height);
  background: var(--edge-color-surface-bg-highest);
  border-radius: var(--game-frame-radius, var(--edge-radius-md))
    var(--game-frame-radius, var(--edge-radius-md)) var(--game-frame-radius, var(--edge-radius-md))
    var(--game-frame-radius, var(--edge-radius-md));
  justify-content: space-between;
  align-items: center;

静态打包证据;未执行浏览器或服务端操作。

SUP21 止盈止损组件CSS使用双等宽grid,stacked标签切column-reverse,并隐藏数字输入spinners。

assets/GameStopProfitLoss.BMR_r6oL.css · 字符偏移 205 · 静态源码

格式化上下文 · 第1行起;原始精确片段保留在证据JSON。打开带行号阅读版

.label-wrapper.svelte-1n5yu4v {
  flex-direction: row-reverse;
  align-items: center;
  display: inline-flex;
  position: relative;
}
.label-wrapper.stacked.svelte-1n5yu4v {
  flex-direction: column-reverse;
  align-items: flex-start;
}
.content.svelte-1n5yu4v {
  grid-template-columns: 1fr 1fr;
  width: 100%;
  height: 100%;
  display: grid;
  overflow: auto;
}
.content.svelte-1n5yu4v .input-wrap {
  height: 100%;
}
.content.svelte-1n5yu4v input::-webkit-outer-spin-button {
  appearance: none;
  margin: var(--spacing-none);
}
.content.svelte-1n5yu4v input::-webkit-inner-spin-button {

静态打包证据;未执行浏览器或服务端操作。

SUP22 共享game-content wrapper测量宽度,以ceil(width*.7)设置minHeight;gameScale=max(width/900,.5);嵌入stats仅特定view与stacked展示。

chunks/EVGMkspg.mjs · 字符偏移 14294 · 静态源码

格式化上下文 · 第964行起;原始精确片段保留在证据JSON。打开带行号阅读版

function bt(e, n) {
  V(n, !0);
  let s = () => z(b, `$stacked`, d),
    c = () => z(he, `$view`, d),
    u = () => z(_, `$scale`, d),
    [d, p] = f(),
    m = t(void 0),
    _ = _t(),
    b = Ae(),
    x = D(n, `noPadding`, 3, !1),
    S = y(() => R(m)?.width || 0),
    w = y(() => Math.ceil(R(S) * 0.7)),
    T = () => {
      s() === !1 && (c() === `embedded` || c() === `minimized`) && he.set(`bets`);
    };
  (T(),
    i(() => {
      T();
    }));
  var E = yt();
  let O, k;
  var A = M(E);
  let N;
  var P = M(A);
  (G(

静态打包证据;未执行浏览器或服务端操作。

SUP23 共享game fairness modal是overview/seeds/verify三tab,关闭时replaceState当前pathname;info modal把rules/limits/extraPages映射动态组件。

chunks/EVGMkspg.mjs · 字符偏移 15149 · 静态源码

格式化上下文 · 第1021行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Ct(t, n) {
  V(n, !0);
  let r = () => z(m, `$modal`, c),
    i = () => z(q, `$page`, c),
    a = () => z(ze, `$tab`, c),
    s = () => z(J, `$i18n`, c),
    [c, u] = f(),
    m = Z()?.modal || xt,
    _ = [
      { tab: `overview`, message: Fe.overview },
      { tab: `seeds`, message: Fe.seeds },
      { tab: `verify`, message: Fe.verify },
    ];
  var v = e(),
    x = p(v),
    C = (t) => {
      tt(t, {
        get title() {
          return Fe.fairness;
        },
        icon: `fairness`,
        onclose: () => {
          (m.set(`hidden`), ne(i().url.pathname, { replaceState: !0 }));
        },
        children: (t, n) => {

静态打包证据;未执行浏览器或服务端操作。

SUP24 游戏生命周期wrapper提供general/autobet context、instance tracking、currency停止联动、game_ready埋点、订阅/退出清理状态。

chunks/DYosYWTC.mjs · 字符偏移 2997 · 静态源码

格式化上下文 · 第23行起;原始精确片段保留在证据JSON。打开带行号阅读版

var O = () => ({ title: { id: `Ifq4hV` }, body: { id: `dDj4u0` }, icon: y, type: `warn` }),
  k = (e, t) => {
    let n = e - t;
    return Math.abs((n / e) * 100);
  },
  A = ({ blockResults: e, balance: t, amount: n, gamesLeft: r, potentialStopLoss: i }) => {
    if (e?.stop) return e.message ?? `conditionalBlockCalledStop`;
    if (r === 1) return `limitReached`;
    if (n > t) return `insufficientBalance`;
    if (i) return `potentialStopLossReached`;
  },
  j = ({ blocks: e, id: t, value: n, blockDefault: r, target: i }) =>
    e.some((e) => e.id === t)
      ? e.map((e) => {
          let r = structuredClone(e);
          return (e.id === t && (r[i].value = n), r);
        })
      : [...e, { ...r, [i]: { ...r[i], value: n } }],
  M = (e) => {
    if (!Array.isArray(e)) return [];
    let t = (e) => typeof e == `object` && !!e,
      n = (e) => typeof e.type == `string` && e.type !== ``,
      r = new Set();
    return e.reduce((e, i) => {
      if (!t(i) || !t(i.on) || !t(i.do) || !n(i.on) || !n(i.do)) return e;

静态打包证据;未执行浏览器或服务端操作。

SUP25 共享策略器使用ordered blocks、saved labels、load/save/reset/default strategies;初始advanced默认Martingale,与具体Dice组件分离复用。

chunks/DBgOd0is.mjs · 字符偏移 8618 · 静态源码

格式化上下文 · 第444行起;原始精确片段保留在证据JSON。打开带行号阅读版

function ae(n) {
  let r = $(0),
    i = n?.actionOptions || T,
    a = { ...n?.validators },
    o = (() => {
      let n = t(!1),
        r = $([]),
        a = $(null);
      r.set([]);
      let s = (e) => r.update((t) => t.filter((t) => t.id !== e));
      return {
        ...r,
        enabled: n,
        add: (e) => r.update((t) => [...t, e]),
        reset: () => r.set([]),
        allowedActions: i,
        editIndex: a,
        remove: s,
        move: ({ position: t, up: n }) => {
          let i = e(r),
            a = n ? t - 1 : t + 1;
          (i[a] && ([i[a], i[t]] = [i[t], i[a]]), r.set([...i]));
        },
        enable: () => {
          (r.update((e) => _({ blocks: e, block: Y }).filter((e) => e.id !== Q.id)),

静态打包证据;未执行浏览器或服务端操作。

SUP26 条件块引擎执行trigger predicate→action→合并结果,停止后剩余块标fail,统计以净balanceDiff定义profit/loss。

chunks/DF2YAqRD.mjs · 字符偏移 3087 · 静态源码

格式化上下文 · 第9行起;原始精确片段保留在证据JSON。打开带行号阅读版

var s = ({ history: e, betType: t, value: n }) => {
    switch (t) {
      case `bet`:
        return e.bets % n === 0;
      case `win`:
        return t === e.streakType && e.wins % n === 0;
      case `lose`:
        return t === e.streakType && e.losses % n === 0;
      default:
        return !1;
    }
  },
  c = (e, t, n) => {
    switch (e) {
      case `every`:
        return t % n === 0;
      case `greater than`:
        return t > n;
      case `greater than or equal to`:
        return t >= n;
      case `lower than`:
        return t < n;
      case `lower than or equal to`:
        return t <= n;
      case `first`:

静态打包证据;未执行浏览器或服务端操作。

SUP27 高级策略编辑UI按block order显示并支持move/delete/minimize;新增块、修改块保存strategy且track策略编辑事件。

chunks/JSjbXZw1.mjs · 字符偏移 27600 · 静态源码

格式化上下文 · 第1838行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Jt(e, n) {
  j(n, !0);
  let r = () => k(y, `$blocks`, m),
    i = () => k(M, `$editIndex`, m),
    o = () => k(x, `$disabled`, m),
    s = () => k(S, `$config`, m),
    d = () => k(F, `$i18n`, m),
    [m, v] = l(),
    { blocks: y, saveStrategy: b } = Z(),
    { disabled: x } = Q(),
    S = Ce(),
    { editIndex: M } = y,
    ee = () => ({
      id: me(8),
      type: `bets`,
      on: { type: `every`, value: 0, betType: `bet`, profitType: `profit` },
      do: { type: `addToAmount`, value: 0 },
    }),
    P = t(void 0),
    I = g(() => O(P) !== void 0 && O(P).width < 375);
  var L = qt(),
    R = T(L);
  (_e(R, {
    gap: `medium`,
    children: (e, t) => {

静态打包证据;未执行浏览器或服务端操作。

SUP28 图标旧registry按字符串icon动态import,Map缓存成功组件;失败fallback到CMPOgggz,避免重复加载,异步回来前比较当前icon以防错位。

chunks/C4Qlohbh.mjs · 字符偏移 61558 · 静态源码

格式化上下文 · 第269行起;原始精确片段保留在证据JSON。打开带行号阅读版

var m = (e) => (e ? `flags-` + e in h : !1),
  h = {
    "flags-abkhazia": () =>
      p(() => import(`./CskXstHo.mjs`), __vite__mapDeps([0, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-ab": () =>
      p(() => import(`./CskXstHo.mjs`), __vite__mapDeps([0, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-afghanistan": () =>
      p(() => import(`./DLSYBZuF.mjs`), __vite__mapDeps([6, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-af": () =>
      p(() => import(`./DLSYBZuF.mjs`), __vite__mapDeps([6, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-aland-islands": () =>
      p(() => import(`./D36MZ1C0.mjs`), __vite__mapDeps([7, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-ax": () =>
      p(() => import(`./D36MZ1C0.mjs`), __vite__mapDeps([7, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-albania": () =>
      p(() => import(`./D348qVso.mjs`), __vite__mapDeps([8, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-al": () =>
      p(() => import(`./D348qVso.mjs`), __vite__mapDeps([8, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-algeria": () =>
      p(() => import(`./DUj0fKXO.mjs`), __vite__mapDeps([9, 1, 2, 3, 4, 5]), import.meta.url),
    "flags-dz": () =>
      p(() => import(`./DUj0fKXO.mjs`), __vite__mapDeps([9, 1, 2, 3, 4, 5]), import.meta.url),
    america: () =>
      p(
        () => import(`./DDMfxl3f.mjs`).then((e) => e.n),

静态打包证据;未执行浏览器或服务端操作。

SUP29 另一套named Icon registry为每个命名组件提供动态import函数,包含货币/国旗/运动/系统图标;图标名称不是功能实现证据。

chunks/BYqH8GVS.mjs · 字符偏移 110539 · 静态源码

格式化上下文 · 第862行起;原始精确片段保留在证据JSON。打开带行号阅读版

var t = {
  AdjustIcon: () =>
    e(
      () => import(`./CGMacSC0.mjs`).then((e) => e.n),
      __vite__mapDeps([0, 1, 2, 3, 4, 5]),
      import.meta.url,
    ),
  AffiliateIcon: () =>
    e(
      () => import(`./Dj-N7seM.mjs`).then((e) => e.n),
      __vite__mapDeps([6, 1, 2, 3, 4, 5]),
      import.meta.url,
    ),
  AfghanistanFlagIcon: () =>
    e(() => import(`./DLSYBZuF.mjs`), __vite__mapDeps([7, 2, 1, 3, 4, 5]), import.meta.url),
  AFLIcon: () =>
    e(() => import(`./BigT5k_F.mjs`), __vite__mapDeps([8, 2, 1, 3, 4, 5]), import.meta.url),
  AgeOfEmpiresIcon: () =>
    e(() => import(`./CnUuPBEc.mjs`), __vite__mapDeps([9, 2, 1, 3, 4, 5]), import.meta.url),
  AlandIslandsFlagIcon: () =>
    e(() => import(`./D36MZ1C0.mjs`), __vite__mapDeps([10, 2, 1, 3, 4, 5]), import.meta.url),
  AlbaniaFlagIcon: () =>
    e(() => import(`./D348qVso.mjs`), __vite__mapDeps([11, 2, 1, 3, 4, 5]), import.meta.url),
  AlgeriaFlagIcon: () =>
    e(() => import(`./DUj0fKXO.mjs`), __vite__mapDeps([12, 2, 1, 3, 4, 5]), import.meta.url),

静态打包证据;未执行浏览器或服务端操作。

SUP30 空状态插图registry包含search/betslip/notifications等动态组件,加载失败回灰色插图;使用200ms过渡。

chunks/JvUC7iNO.mjs · 字符偏移 6522 · 静态源码

格式化上下文 · 第70行起;原始精确片段保留在证据JSON。打开带行号阅读版

function T(m, v) {
  let S = p(v, `spacing`, 3, `normal`),
    T = {
      market: () =>
        b(() => import(`./BqcH4L0y.mjs`), __vite__mapDeps([0, 1, 2, 3]), import.meta.url),
      sports: () =>
        b(() => import(`./CIqCWjO2.mjs`), __vite__mapDeps([4, 1, 2, 3]), import.meta.url),
      "fiat-payment": () =>
        b(() => import(`./BEyoAJv3.mjs`), __vite__mapDeps([5, 1, 2, 3]), import.meta.url),
      betslip: () =>
        b(() => import(`./8OJE90Yx.mjs`), __vite__mapDeps([6, 1, 2, 3]), import.meta.url),
      "my-bets-settled": () =>
        b(() => import(`./DOz3nxYs.mjs`), __vite__mapDeps([7, 1, 2, 3]), import.meta.url),
      "icon-uploading": () =>
        b(() => import(`./BGZdcKFB.mjs`), __vite__mapDeps([8, 1, 2, 3]), import.meta.url),
      "empty-fixture": () =>
        b(() => import(`./C1hn_iqu.mjs`), __vite__mapDeps([9, 1, 2, 3]), import.meta.url),
      search: () =>
        b(() => import(`./BkcPG7i9.mjs`), __vite__mapDeps([10, 1, 2, 3]), import.meta.url),
      "empty-promotions": () =>
        b(() => import(`./C73pagtJ.mjs`), __vite__mapDeps([11, 1, 2, 3]), import.meta.url),
      races: () =>
        b(() => import(`./BxJVX_3I.mjs`), __vite__mapDeps([12, 1, 2, 3]), import.meta.url),
      "empty-blogs": () =>
        b(() => import(`./DYyY8DA4.mjs`), __vite__mapDeps([13, 1, 2, 3]), import.meta.url),

静态打包证据;未执行浏览器或服务端操作。

SUP31 首页构建recent、trending、personalised、originals数据视图;recommendation保留modelVersion/sequenceId;sweeps分支与普通分支分别渲染Tn/yn。

nodes/55.BHHpgWjN.mjs · 字符偏移 43825 · 静态源码

格式化上下文 · 第2372行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Mn(e, r) {
  j(r, !0);
  let i = () => k(W, `$i18n`, l),
    o = () => k(re, `$locale`, l),
    c = () => k(te, `$page`, l),
    [l, _] = u(),
    y = He(Z.type),
    b = g(() => r.data.vipProgress),
    x = g(() => r.data.userRecentGameList),
    S = g(() => r.data.trendingGamesList),
    w = g(() => r.data.trendingSportsList),
    E = g(() => r.data.heroes),
    A = g(() => r.data.promotions),
    M = g(() => r.data.seo),
    N = g(() => r.data.kuratorCollection),
    F = g(() => r.data.personalisedRecommendationGames),
    I = g(() => ({
      group: {
        slug: `recent-games`,
        to: `/casino/recent`,
        icon: `continue`,
        translation: i()._(ze.recentGames),
        gameCount: 0,
      },
      cards: O(x)?.map((e) => e) || [],

静态打包证据;未执行浏览器或服务端操作。

SUP32 首页BetsBoard只在visibility为true时dynamic import,提供占位与chunk failed日志;首页其他部分有authenticated分支。

nodes/55.BHHpgWjN.mjs · 字符偏移 39019 · 静态源码

格式化上下文 · 第1751行起;原始精确片段保留在证据JSON。打开带行号阅读版

function yn(e, n) {
  j(n, !0);
  let r = () => k(U, `$isSportsbookEnabledForRegion`, a),
    i = () => k(v, `$meta`, a),
    [a, o] = u(),
    c = b(n, `heroes`, 19, () => []),
    h = b(n, `promotions`, 19, () => []),
    _ = b(n, `personalisedGames`, 3, null),
    { meta: v } = le(),
    y = g(
      () => [...(n.trendingGames?.cards ?? []), ...(n.trendingSports?.cards ?? [])].length === 0,
    ),
    x = g(r);
  var S = t(),
    w = d(S);
  (m(
    w,
    () => $e,
    (e, r) => {
      r(e, {
        children: (e, r) => {
          var a = t(),
            o = d(a);
          (m(
            o,

静态打包证据;未执行浏览器或服务端操作。

SUP33 通用modal组件异步加载selected modal,支持persistent/restricted/darkOverlay/preventOutsideClose;Escape关闭并清事件监听;chunk网络错误有专门记录。

chunks/Dh3-ySZv.mjs · 字符偏移 156664 · 静态源码

格式化上下文 · 第5336行起;原始精确片段保留在证据JSON。打开带行号阅读版

function Ra(e, n) {
  A(n, !0);
  let r = () => O(ze, `$modalPage`, o),
    a = () => O(c, `$meta`, o),
    [o, s] = l();
  L.set(Pa);
  let { meta: c } = V(),
    u = b(n, `loadingState`, 3, !1),
    d = _(() => {
      let e = {};
      return (
        r().url.searchParams.forEach((t, n) => {
          e[n] = t;
        }),
        e
      );
    }),
    f = _(() => (n.modal in Fa ? Fa[n.modal] : null));
  document.activeElement instanceof HTMLElement && document.activeElement.blur();
  let p = () => {
      (n.onclose?.(), D(x) || le(r()));
    },
    m = (e) => {
      let { key: t } = e;
      t === `Escape` && p();

静态打包证据;未执行浏览器或服务端操作。

SUP34 游戏动态registry有33个key,Dice/Mines等按需加载组件且携带CSS/modulepreload依赖;列表包含共同生产构建能力,不等同匿名可用。

chunks/Ds1noQDJ.mjs · 字符偏移 37190 · 静态源码

格式化上下文 · 第742行起;原始精确片段保留在证据JSON。打开带行号阅读版

var k = {
    defaultXPosition: 20,
    defaultYPosition: 20,
    titleHeight: 38,
    containerWidth: 400,
    containerWidthExpanded: 800,
  },
  A = (e) => t(u).some((t) => t.slug === e),
  j = a(`draggable`),
  M = { x: k.defaultXPosition, y: k.defaultYPosition, container: void 0 },
  N = (e) => {
    let n = () => j(e, M);
    return {
      get: () => t(n()).dragged,
      unset: () => {
        n().update((e) => ({ ...e, dragged: !1 }));
      },
    };
  },
  P = (e) => (e.isStakeOriginal ? `stake-game-${e.slug}` : `slots`),
  F = n(u, (e) => e.some((e) => e.isStakeOriginal)),
  I = n(u, (e) => e.some((e) => e.minimized)),
  L = n([d, I], ([e, t]) =>
    e && t ? f.minimizedTabHeight + f.defaultPositionOffsetWithMinimizedTabs : 0,
  ),

静态打包证据;未执行浏览器或服务端操作。