@ikenxuan/amagi 6.6.0 → 7.0.0-beta.2

package/dist/tokens-BFqSOfhx.mjs

@@ -0,0 +1,1001 @@
+//#region src/platforms/douyin/sign/sm3.ts
+/**
+* SM3 哈希（GB/T 32905-2016），纯 TS 实现。
+*
+* 抖音的 a_bogus 用它摘要 query / body / User-Agent。这个文件是移植件，
+* 来源是 Douyin_TikTok_Download_API 的 `signing/native/sm3.py`（Apache-2.0），
+* 与本仓库的 GPL-3.0 兼容。
+*
+* ## 为什么不用 passport/sm3.ts
+*
+* 那个是登录侧的另一份 SM3，入口收 `string` 并按 `charCodeAt` 逐字符取字节 ——
+* 对中文会与 UTF-8 不同。a_bogus 要摘的是 query 与 base64 串（纯 ASCII），
+* 但 UA 链上要摘要的是**按 JS 语义切出来的字节**，两份混用迟早出错，所以
+* 签名侧自带一份以字节为入口的实现，不复用。
+*
+* ## 移植时改了什么
+*
+* 只改了整数语义：Python 的 `& 0xFFFFFFFF` 在 JS 里必须写成 `>>> 0`，
+* 否则位运算的结果是带符号 32 位整数，`~x` 与算术右移都会带进符号位。
+* 摘要字节输出与 Python 逐字节一致。
+*/
+/** 32 位掩码，JS 位运算全是带符号的，每步之后都要用它收回无符号域 */
+const MASK = 4294967295;
+/** SM3 初始向量 */
+const SM3_IV = [
+	1937774191,
+	1226093241,
+	388252375,
+	3666478592,
+	2842636476,
+	372324522,
+	3817729613,
+	2969243214
+];
+const T0 = 2043430169;
+const T1 = 2055708042;
+/** 循环左移。`bits % 32 === 0` 时 JS 的移位计数会自动取模，结果仍正确 */
+const rotl = (value, bits) => {
+	const n = bits % 32;
+	return (value << n & MASK | value >>> 32 - n) >>> 0;
+};
+const ff = (index, x, y, z) => index < 16 ? (x ^ y ^ z) >>> 0 : (x & y | x & z | y & z) >>> 0;
+const gg = (index, x, y, z) => index < 16 ? (x ^ y ^ z) >>> 0 : (x & y | ~x & z) >>> 0;
+/** 消息扩展：16 个字扩到 68 个，再派生 64 个 `w1` */
+const expand = (block) => {
+	const w = block.slice(0, 16);
+	for (let i = 16; i < 68; i++) {
+		let x = (w[i - 16] ^ w[i - 9] ^ rotl(w[i - 3], 15)) >>> 0;
+		x = (x ^ rotl(x, 15) ^ rotl(x, 23)) >>> 0;
+		w.push((x ^ rotl(w[i - 13], 7) ^ w[i - 6]) >>> 0);
+	}
+	const w1 = [];
+	for (let i = 0; i < 64; i++) w1.push((w[i] ^ w[i + 4]) >>> 0);
+	return {
+		w,
+		w1
+	};
+};
+/** 压缩函数：8 字状态与一个 512 位分组混合 */
+const compress = (state, block) => {
+	const { w, w1 } = expand(block);
+	let [a, b, c, d, e, f, g, h] = state;
+	for (let j = 0; j < 64; j++) {
+		const t = j < 16 ? T0 : T1;
+		const ss1 = rotl(rotl(a, 12) + e + rotl(t, j) & MASK, 7);
+		const ss2 = (ss1 ^ rotl(a, 12)) >>> 0;
+		const tt1 = ff(j, a, b, c) + d + ss2 + w1[j] & MASK;
+		const tt2 = gg(j, e, f, g) + h + ss1 + w[j] & MASK;
+		d = c;
+		c = rotl(b, 9);
+		b = a;
+		a = tt1;
+		h = g;
+		g = rotl(f, 19);
+		f = e;
+		e = (tt2 ^ rotl(tt2, 9) ^ rotl(tt2, 17)) >>> 0;
+	}
+	return state.map((word, index) => (word ^ [
+		a,
+		b,
+		c,
+		d,
+		e,
+		f,
+		g,
+		h
+	][index]) >>> 0);
+};
+/** 填充：补 `0x80`、补零到 56 mod 64、末尾写 64 位大端比特长度 */
+const pad = (message) => {
+	const bitLength = message.length * 8;
+	const padded = message.slice();
+	padded.push(128);
+	while (padded.length % 64 !== 56) padded.push(0);
+	const high = Math.floor(bitLength / 4294967296);
+	const low = bitLength >>> 0;
+	padded.push(high >>> 24 & 255, high >>> 16 & 255, high >>> 8 & 255, high & 255);
+	padded.push(low >>> 24 & 255, low >>> 16 & 255, low >>> 8 & 255, low & 255);
+	return padded;
+};
+/**
+* 计算 SM3 摘要。
+* @param message - 待摘要的字节
+* @returns 32 字节摘要
+*/
+const sm3Hash = (message) => {
+	const padded = pad(message);
+	let state = SM3_IV.slice();
+	for (let offset = 0; offset < padded.length; offset += 64) {
+		const block = [];
+		for (let i = 0; i < 16; i++) {
+			const at = offset + i * 4;
+			block.push((padded[at] << 24 | padded[at + 1] << 16 | padded[at + 2] << 8 | padded[at + 3]) >>> 0);
+		}
+		state = compress(state, block);
+	}
+	const out = [];
+	for (const word of state) out.push(word >>> 24 & 255, word >>> 16 & 255, word >>> 8 & 255, word & 255);
+	return out;
+};
+/** 摘要的十六进制形式，便于与公开测试向量对照 */
+const sm3Hexdigest = (message) => sm3Hash(message).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+/**
+* 摘要为 32 个整数的数组，与 a_bogus 内部各处取字节的方式对齐。
+*
+* 字符串按 **UTF-8** 编码后摘要（与 `sm3.py` 的 `sm3_to_array` 一致）。
+* 注意 a_bogus 里另有一处 `jsBytes`，那个走的是 JS `charCodeAt` 语义，
+* 两者不可互换 —— 见 `a_bogus.ts` 的说明。
+* @param data - 字符串、字节数组或整数数组
+* @returns 32 个 0..255 的整数
+*/
+const sm3ToArray = (data) => sm3Hash(typeof data === "string" ? Array.from(new TextEncoder().encode(data)) : Array.from(data));
+//#endregion
+//#region src/platforms/douyin/sign/a_bogus.ts
+/**
+* a_bogus —— 抖音 Web 加在每个数据接口上的签名。
+*
+* ## 出处
+*
+* 移植自 Douyin_TikTok_Download_API 的 `signing/native/abogus.py`（Apache-2.0，
+* 与本仓库 GPL-3.0 兼容）。那份是**自己逆向**抖音的 `bdms.js` v1.0.1.19-fix.01
+* 得到的（2026-09-09），不是抄来的片段。
+*
+* 本文件**替换**了原先那份 2024-08 从公开片段原样复制的实现。两份的差别不是
+* 代码风格，是常量：
+*
+* | | 旧实现 | 本实现 |
+* |---|---|---|
+* | 摘要盐值 | `cus` | `dhzx` |
+* | 几何串 | 17 段、写死 `1536\|747\|…` | 9 段、可传入 |
+* | 时钟 / 随机源 | 直接读 `Date.now()` / `Math.random()` | 可注入 |
+* | 能否解码自证 | 否 | 是，见 {@link decode} |
+*
+* 盐值那条是**实测结论**而非推测：拿真实浏览器（bdms 1.0.1.19-fix.01，2026-09-09
+* 捕获）产出的签名反推，三条摘要链在 `dhzx` 下全部命中，在 `cus` 下 query 与 body
+* 两条都对不上。旧盐值能让请求偶尔通过，是因为抖音**抽样校验**——签名过期不报错，
+* 只表现为被判定为高风险的概率上升，所以这个 bug 活了两年没被发现。
+*
+* ## 为什么可注入是重点
+*
+* 旧的 `export default (url, user_agent) => string` 收不下 `now_ms`、`browser_info`
+* 和随机源，于是**无法对着固定样本复现**——而没有复现能力，就没有任何测试能证伪
+* 一个常量。这正是盐值能过期两年的结构性原因。所以本文件的入口是
+* {@link ABogus} 类，`rng` / `nowMs` / `browserInfo` 全部可注入，默认值保持生产可用。
+*
+* ## 噪声不是均匀随机的
+*
+* `Math.random` 永远进不了校验和、也改不了任何可解码字段，所以同一毫秒内的两个
+* 签名大部分字节不同、含义相同。但**这不等于噪声可以随便填**：其中有三个字节不是
+* 噪声，是 SDK 对自己的环境回报（它认为自己在哪个浏览器家族里、自己的探针是否还
+* 在），任何拿到签名的人都能读回去。均匀随机写进去，落在浏览器不可能产出的取值上
+* 就是一个把柄——{@link HEADER_NOISE_BANDS} 与 {@link tripwireNoise} 就是为此存在。
+*/
+/** bdms.js 携带的五张字母表中，本文件用得到的两张：`s4` 编码成品签名，`s3` 编码进入第三条摘要的 UA */
+const ALPHABETS = {
+	s3: "ckdp1h4ZKsUB80/Mfvw36XIgR25+WQAlEi7NLboqYTOPuzmFjJnryx9HVGDaStCe",
+	s4: "Dkdpgh2ZmsQB80/MfvV36XI1R45-WUAlEixNLwoqYTOPuzKFjJnry79HbGcaStCe"
+};
+/** 摘要前拼在 query 与 body 后面的盐值。实测值，不是猜的——见文件头 */
+const SALT = "dhzx";
+/** header 携带的两个明文字节，是这套格式最接近魔数的东西，也是 {@link structureError} 的第一道检查 */
+const HEADER_MAGIC = [3, 82];
+/** `"1.0.1.19-fix.01"` 被 SDK 解析后的版本块，实测解码结果 */
+const SDK_VERSION = [
+	1,
+	0,
+	1,
+	0
+];
+/** 单字节，且是全部的密钥。密文不是教科书 RC4，见 {@link rc4} */
+const PAYLOAD_KEY = 211;
+/** `2024-07-24T16:00:00Z`，有一个字段从此刻起数「两周」 */
+const FORTNIGHT_EPOCH_MS = 17218368e5;
+/** 抖音 Web 自己的标识，不是我们能选的：它同时出现在签名里和 query 里，两边不一致就是最廉价的把柄 */
+const PAGE_ID = 6241;
+const AID = 6383;
+/** 噪声层用三字节藏一个字节，两张掩码互补：`0x91 | 0x42 | 0x2C === 0xFF`，这是整个噪声层可逆的原因 */
+const NOISE_MASKS = [
+	145,
+	66,
+	44
+];
+const DATA_MASKS = [
+	110,
+	189,
+	211
+];
+/**
+* 五十个标量字段在 body 里的排列顺序。
+*
+* 不是密码，只是一个固定置换；写成字面量而不是算出来，是因为字节码里就是这样，
+* 而且照着真实捕获核对的人希望看到和解码器打印的同一个顺序。
+*/
+const FIELD_ORDER = [
+	"L34",
+	"L44",
+	"L56",
+	"L61",
+	"L73",
+	"L29",
+	"L70",
+	"L45",
+	"L35",
+	"L49",
+	"L38",
+	"L66",
+	"L51",
+	"L68",
+	"L28",
+	"L48",
+	"L64",
+	"L47",
+	"L30",
+	"L71",
+	"L26",
+	"L55",
+	"L31",
+	"L69",
+	"L59",
+	"L40",
+	"L62",
+	"L63",
+	"L27",
+	"L72",
+	"L41",
+	"L74",
+	"L57",
+	"L52",
+	"L42",
+	"L39",
+	"L33",
+	"L67",
+	"L53",
+	"L43",
+	"L65",
+	"L46",
+	"L36",
+	"L24",
+	"L60",
+	"L32",
+	"L79",
+	"L80",
+	"L84",
+	"L85"
+];
+/** 三条摘要链的哨兵三元组：`[哨兵, 偏移, 兜底]`。写哨兵本身是 SDK 报告自己环境探针触发的暗号，我们永远写诚实值 */
+const CANARIES = [
+	[
+		3,
+		11,
+		12
+	],
+	[
+		4,
+		8,
+		9
+	],
+	[
+		5,
+		12,
+		13
+	]
+];
+/**
+* 三个被摘要的输入各自落在哪些标量上。
+*
+* 生成器和解码器**读同一张表**，所以解码器不可能与它所解的东西漂移。
+*
+* 每个输入三个字节就是全部的绑定，这个不对称正是重点：足够**证明**某个 query /
+* body / UA 就是这份签名封住的那一个，又远不足以把哈希倒推回去。把它们报成
+* 「query 本身」的解码器是在编造；拿候选值去校验的解码器才在说真话。
+*/
+const DIGEST_CHAINS = {
+	query: {
+		slots: [
+			"L48",
+			"L49",
+			"L51"
+		],
+		indices: [9, 18],
+		canary: CANARIES[0]
+	},
+	body: {
+		slots: [
+			"L52",
+			"L53",
+			"L55"
+		],
+		indices: [10, 19],
+		canary: CANARIES[1]
+	},
+	user_agent: {
+		slots: [
+			"L56",
+			"L57",
+			"L59"
+		],
+		indices: [11, 21],
+		canary: CANARIES[2]
+	}
+};
+/** 未被插桩的真实页面回报的环境值：六个探针加一个反机器人位集 */
+const ENV_FLAGS = 1;
+const DETECT_FLAGS = 14;
+const NR_TAG = [
+	0,
+	0,
+	0,
+	0
+];
+/** `window.onwheelx._Ax` 存在且被冻结——SDK 给自己装上再冻住的状态。12 表示被人解锁、11 表示缺失，两者都是抖音能打分的特征 */
+const TRIPWIRE_LOCKED = 3;
+/** `fn149` 给每页签名计数器分桶。6 表示「本页签名少于 140 次」，浏览器一生中大部分时间都在这里 */
+const CALL_BUCKET = 6;
+/** 1080p 上的 Chrome。指纹里没有屏幕尺寸时用它——**一个可信的常量好过随机值**，随请求变的几何本身就是特征 */
+const DEFAULT_BROWSER_INFO = "1920|947|1920|1032|1920|1032|1920|1080|Win32";
+/** 从屏幕高度猜可视区时要减掉的系统任务栏与浏览器自身 chrome */
+const TASKBAR_PX = 48;
+const CHROME_PX = 85;
+/**
+* SDK 认为自己身处哪个浏览器家族，按 `fn143` 的口径：每个家族一条 40 宽的带。
+*
+* 这些带**盖不满 0..255**。落在缝隙里的值没有浏览器能产出；落在错误家族带里的值与
+* 旁边发出去的 User-Agent 自相矛盾——两者都是抖音免费可打的分。均匀随机有 6% 的
+* 概率落进缝隙、78% 的概率落错家族。
+*/
+const HEADER_NOISE_BANDS = {
+	chrome: 0,
+	firefox: 40,
+	safari: 81,
+	edge: 125,
+	huawei: 170,
+	other: 210
+};
+/** `fn145` 的健康位型：三个探针都在且被冻住。均匀随机有 94% 的概率报告出一个被剥离或解锁的页面 */
+const TRIPWIRE_SET = 178;
+const TRIPWIRE_FREE = 77;
+const toByte = (value) => value & 255;
+/**
+* 按九个字段拼出签名会逐字携带的 `navigator`/`screen` 串。
+*
+* 顺序不可商量：这是载荷里唯一一路以可读文本活到校验和的部分。
+* @param parts - 九个字段，顺序同 SDK 自己的对象字面量
+* @returns 以 `|` 连接的几何串
+*/
+const buildBrowserInfo = (parts) => [
+	parts.innerWidth,
+	parts.innerHeight,
+	parts.outerWidth,
+	parts.outerHeight,
+	parts.availWidth,
+	parts.availHeight,
+	parts.screenWidth,
+	parts.screenHeight,
+	parts.platform
+].join("|");
+/**
+* 由一个屏幕尺寸推出一组自洽的九字段几何串。
+*
+* 浏览器报的四个矩形并不独立：窗口不超过工作区，工作区是屏幕减系统栏，可视区是窗口
+* 减浏览器自身。从一个数派生能让它们互相自洽，而随机拼出来的一组不会。
+* @param width - 屏幕宽
+* @param height - 屏幕高
+* @param platform - `navigator.platform`
+* @returns 九字段几何串
+*/
+const browserInfoFromScreen = (width, height, platform) => {
+	const availHeight = Math.max(height - TASKBAR_PX, 1);
+	return buildBrowserInfo({
+		innerWidth: width,
+		innerHeight: Math.max(availHeight - CHROME_PX, 1),
+		outerWidth: width,
+		outerHeight: availHeight,
+		availWidth: width,
+		availHeight,
+		screenWidth: width,
+		screenHeight: height,
+		platform
+	});
+};
+/**
+* SDK 的 RC4 —— 但它不是 RC4。
+*
+* 两处刻意偏离，都在初始化：S 盒以**降序**恒等排列起手，密钥编排在教科书版本只做加法的
+* 地方做了乘法。密钥流生成部分没动。
+*
+* 这两处的意义比看起来大：合起来意味着拿标准 RC4 去暴力试每一个单字节密钥，对捕获到的
+* 载荷一无所获。逆向方在读懂字节码之前正是卡在这里，而这多半就是它们存在的理由。
+* @param key - 密钥字节
+* @param data - 待处理数据
+* @returns 与输入等长的结果
+*/
+const rc4 = (key, data) => {
+	const box = new Array(256);
+	for (let i = 0; i < 256; i++) box[255 - i] = i;
+	let j = 0;
+	for (let i = 0; i < 256; i++) {
+		j = (j * box[i] + j + key[i % key.length]) % 256;
+		const swap = box[i];
+		box[i] = box[j];
+		box[j] = swap;
+	}
+	const out = new Array(data.length);
+	let i = 0;
+	j = 0;
+	for (let index = 0; index < data.length; index++) {
+		i = (i + 1) % 256;
+		j = (j + box[i]) % 256;
+		const swap = box[i];
+		box[i] = box[j];
+		box[j] = swap;
+		out[index] = data[index] ^ box[(box[i] + box[j]) % 256];
+	}
+	return out;
+};
+/**
+* 按 SDK 的字母表做 base64，补位是字面量 `=`。
+* @param data - 待编码字节
+* @param alphabet - `s3` 或 `s4`
+* @returns base64 文本
+*/
+const encodeBase64 = (data, alphabet = "s4") => {
+	const table = ALPHABETS[alphabet];
+	const out = [];
+	for (let offset = 0; offset < data.length; offset += 3) {
+		const chunk = data.slice(offset, offset + 3);
+		let block = 0;
+		for (let i = 0; i < 3; i++) block = block << 8 | (i < chunk.length ? chunk[i] : 0);
+		const digits = [
+			block >>> 18 & 63,
+			block >>> 12 & 63,
+			block >>> 6 & 63,
+			block & 63
+		];
+		for (const digit of digits.slice(0, chunk.length + 1)) out.push(table[digit]);
+	}
+	const padCount = (4 - out.length % 4) % 4;
+	for (let i = 0; i < padCount; i++) out.push("=");
+	return out.join("");
+};
+/**
+* {@link encodeBase64} 的逆。遇到非本表字符时抛错。
+* @param text - base64 文本
+* @param alphabet - `s3` 或 `s4`
+* @returns 解出的字节
+*/
+const decodeBase64 = (text, alphabet = "s4") => {
+	const table = ALPHABETS[alphabet];
+	const index = /* @__PURE__ */ new Map();
+	for (let i = 0; i < table.length; i++) index.set(table[i], i);
+	const body = text.replace(/=+$/, "");
+	const out = [];
+	for (let offset = 0; offset < body.length; offset += 4) {
+		const chunk = body.slice(offset, offset + 4);
+		let block = 0;
+		for (const char of chunk) {
+			const digit = index.get(char);
+			if (digit === void 0) throw new Error(`不是 ${alphabet} 字母表中的字符：${JSON.stringify(char)}`);
+			block = block << 6 | digit;
+		}
+		block <<= 6 * (4 - chunk.length);
+		const shifts = [
+			16,
+			8,
+			0
+		].slice(0, chunk.length - 1);
+		for (const shift of shifts) out.push(block >>> shift & 255);
+	}
+	return out;
+};
+/**
+* 一个 JS 字符串被 SDK 转成字节的方式——**不是 UTF-8**。
+*
+* `fn139` 走 UTF-16 码元，低于 U+0100 的码元出一个字节，高于的出两个大端字节，
+* 于是代理对变四字节、一个汉字变两字节，而 UTF-8 会给三字节。对着 43 个真实签名测过：
+* 这条规则复现出声明的几何长度 43 次，UTF-8 复现 41 次。
+*
+* 它只在 U+00FF 以上才分叉，所以这个差别一直隐身，直到某个 `navigator.platform`
+* 里带了中文。而几何长度被校验和覆盖，写错会让整帧错位、签名整体失效，
+* 不是某一个字段被弄脏。
+* @param text - 待转换文本
+* @returns 按 JS 码元语义切出的字节
+*/
+const jsBytes = (text) => {
+	const out = [];
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code & 65280) out.push(code >>> 8 & 255);
+		out.push(code & 255);
+	}
+	return out;
+};
+/** 取 `value` 的 `count` 个小端字节 */
+const leBytes = (value, count) => {
+	const out = [];
+	for (let index = 0; index < count; index++) out.push(Math.floor(value / 2 ** (8 * index)) & 255);
+	return out;
+};
+/**
+* 摘要里从 `offset` 起第一个不等于 `sentinel` 的字节。
+*
+* 哨兵是保留值：写它本身是 SDK 告诉服务端自己的环境探针触发了。我们永远不写，
+* 所以这里只会报出摘要本身。
+* @param digest - 该链的摘要
+* @param offset - 起始下标
+* @param sentinel - 保留值
+* @param fallback - 全被保留时的兜底
+* @returns 该槽位的字节
+*/
+const canary = (digest, offset, sentinel, fallback) => {
+	for (let index = offset; index < digest.length; index++) if (digest[index] !== sentinel) return digest[index];
+	return fallback;
+};
+/**
+* `SM3(SM3(text + salt))`，32 个整数。
+*
+* 盐值留成参数是为了**验证**：拿一份真实签名，把候选盐值逐个代进来，看哪一个能
+* 重现签名里封住的那三个字节。旧实现用错盐值两年没被发现，就是因为没有这条路径。
+* @param text - 待摘要文本
+* @param salt - 拼接的盐值
+* @returns 摘要
+*/
+const digestWith = (text, salt) => sm3ToArray(sm3ToArray(text + salt));
+/**
+* `SM3(SM3(text + SALT))`，32 个整数。
+* @param text - 待摘要文本
+* @returns 摘要
+*/
+const digestOf = (text) => digestWith(text, SALT);
+/**
+* 第三条链：把 UA 过一遍非标准 RC4、base64，再摘要**一次**。
+*
+* 与另外两条不同，这里是单次 SM3。RC4 的密钥是三字节，由环境探针拼出来，
+* 所以对同一个身份是常量，不是每次调用都变。
+*
+* ## 密钥必须来自**这份签名自己**报的环境值
+*
+* `flags` 默认取模块常量（签名时就是这两个值），但**解码时必须传入签名里解出的
+* `envFlags` / `detectFlags`** —— 它们随页面环境变（实测见过 14 和 4 两种），
+* 拿常量去校验一份 `detect_flags` 为 4 的签名，这条链必然报「对不上」。
+* 上游那份 Python 实现没有这个参数，这是移植时补的。
+* @param userAgent - 原始 User-Agent
+* @param flags - 环境探针值，默认取本模块的常量
+* @returns 摘要
+*/
+const userAgentDigest = (userAgent, flags = {}) => {
+	const envFlags = flags.envFlags ?? 1;
+	const detectFlags = flags.detectFlags ?? 14;
+	const key = [
+		Math.floor(envFlags / 256),
+		envFlags % 256,
+		detectFlags % 256
+	];
+	const sealed = rc4(key, jsBytes(userAgent.trim()).map(toByte));
+	return sm3ToArray(encodeBase64(sealed, "s3"));
+};
+/**
+* 一条链在给定摘要下贡献的三个字节。
+* @param chain - 链定义
+* @param digest - 该链自己的摘要
+* @returns 三个字节
+*/
+const chainBytes = (chain, digest) => [
+	digest[chain.indices[0]],
+	digest[chain.indices[1]],
+	canary(digest, chain.canary[0], chain.canary[1], chain.canary[2])
+];
+/** 由 UA 判断 `fn143` 会从哪条带取值。顺序要紧：Edge 和华为的 UA 里都写着 Chrome，Chrome 的写着 Safari，SDK 先测具体的再测笼统的 */
+const familyOf = (userAgent) => {
+	const ua = userAgent.toLowerCase();
+	for (const name of [
+		"edg",
+		"huawei",
+		"firefox",
+		"chrome",
+		"safari"
+	]) if (ua.includes(name)) return name === "edg" ? "edge" : name;
+	return "other";
+};
+/** `fn143`：一个扮成噪声的浏览器家族回报 */
+const headerNoise = (userAgent, rng) => HEADER_NOISE_BANDS[familyOf(userAgent)] + Math.floor(rng() * 40) & 255;
+/**
+* `fn144`：`nr()[4] & 64` 为空时走的支，实际就是走这支。
+*
+* 110 以下原样通过，以上 SDK 会把它逼成奇数，于是 110..240 里有一半取不到。
+* 一个均匀字节有 31% 的概率落在取不到的集合里。
+*/
+const probeNoise = (rng) => {
+	const value = Math.floor(rng() * 240);
+	return value > 109 ? value + value % 2 + 1 : value;
+};
+/** `fn145`：「我的探针都在且被冻住」，外加真噪声 */
+const tripwireNoise = (rng) => Math.floor(rng() * 255) & TRIPWIRE_FREE | TRIPWIRE_SET;
+/**
+* 把两个字节摊到四个字节上，每字节的另外一半填噪声。
+*
+* 每个输出字节从载荷取一半位、从噪声字节取一半，掩码交替为 `0xAA`/`0x55`。还原只需要
+* 载荷那一半——但噪声那一半同样可还原，而 SDK 在其中两处拿它说了关于自己的事。
+* `low` / `high` 就是调用方提供这些回报的途径；不给时就是 SDK 无事可报时的普通抽取。
+*/
+const maskPair = (pair, rng, overrides = {}) => {
+	const noise = Math.floor(rng() * 65535);
+	const low = toByte(overrides.low === void 0 ? noise & 255 : overrides.low);
+	const high = toByte(overrides.high === void 0 ? noise >>> 8 & 255 : overrides.high);
+	return [
+		low & 170 | pair[0] & 85,
+		low & 85 | pair[0] & 170,
+		high & 170 | pair[1] & 85,
+		high & 85 | pair[1] & 170
+	];
+};
+/** {@link maskPair} 的逆：把每个字节的载荷半边取回来 */
+const unmaskPair = (carrier) => [carrier[0] & 85 | carrier[1] & 170, carrier[2] & 85 | carrier[3] & 170];
+/**
+* 三个 body 字节加一个噪声字节变成四个载体字节。
+*
+* 每个载体留一部分自己的字节、其余从噪声取；第四个字节恰好收拢前三个让出去的位，
+* 且落在它们原来的位位置上。字节内部没有任何位移，这既是这一层可逆的原因，
+* 也是它看起来仍像密文的原因。
+*/
+const expandNoise = (body, rng) => {
+	const out = [];
+	for (let offset = 0; offset < body.length; offset += 3) {
+		const group = body.slice(offset, offset + 3);
+		if (group.length < 3) {
+			out.push(group[0]);
+			if (group.length > 1 && group[1]) out.push(group[1]);
+			continue;
+		}
+		const noise = Math.floor(rng() * 1e3) & 255;
+		for (let index = 0; index < 3; index++) out.push(noise & NOISE_MASKS[index] | group[index] & DATA_MASKS[index]);
+		out.push(group[0] & NOISE_MASKS[0] | group[1] & NOISE_MASKS[1] | group[2] & NOISE_MASKS[2]);
+	}
+	return out;
+};
+/** {@link expandNoise} 的逆 */
+const collapseNoise = (frame) => {
+	const out = [];
+	for (let offset = 0; offset < frame.length; offset += 4) {
+		const group = frame.slice(offset, offset + 4);
+		if (group.length < 4) {
+			out.push(...group);
+			continue;
+		}
+		for (let index = 0; index < 3; index++) out.push(group[index] & DATA_MASKS[index] | group[3] & NOISE_MASKS[index]);
+	}
+	return out;
+};
+/**
+* 为一个浏览器身份计算 `a_bogus`。
+*
+* 除配置外无状态、也很便宜，所以「一个身份一个实例」是自然的生命周期。
+* `rng` 存在的意义是让测试能钉住噪声——它产出什么，签名都是对的。
+*/
+var ABogus = class {
+	userAgent;
+	browserInfo;
+	pageId;
+	aid;
+	envFlags;
+	detectFlags;
+	rng;
+	constructor(userAgent, options = {}) {
+		this.userAgent = userAgent;
+		this.browserInfo = options.browserInfo ?? "1920|947|1920|1032|1920|1032|1920|1080|Win32";
+		this.pageId = options.pageId ?? 6241;
+		this.aid = options.aid ?? 6383;
+		this.envFlags = options.envFlags ?? 1;
+		this.detectFlags = options.detectFlags ?? 14;
+		this.rng = options.rng ?? Math.random;
+	}
+	/** 五十个标量，按离线解码器打印的名字 */
+	fields(query, body, nowMs) {
+		const digests = {
+			query: digestOf(query),
+			body: digestOf(body),
+			user_agent: userAgentDigest(this.userAgent, {
+				envFlags: this.envFlags,
+				detectFlags: this.detectFlags
+			})
+		};
+		const ink = nowMs - 1;
+		const fortnights = Math.floor((nowMs - FORTNIGHT_EPOCH_MS) / 12096e5);
+		const infoBytes = jsBytes(this.browserInfo);
+		const tailBytes = jsBytes(`${nowMs + 3 & 255},`);
+		const fields = {
+			L24: 41,
+			L26: fortnights,
+			L27: 6,
+			L28: 3,
+			L35: this.envFlags & 255,
+			L36: this.envFlags >>> 8 & 255,
+			L38: 33,
+			L39: 0,
+			L66: 3,
+			L79: infoBytes.length & 255,
+			L80: infoBytes.length >>> 8 & 255,
+			L84: tailBytes.length & 255,
+			L85: tailBytes.length >>> 8 & 255
+		};
+		leBytes(nowMs, 6).forEach((byte, index) => fields[`L${29 + index}`] = byte);
+		leBytes(this.detectFlags, 4).forEach((byte, index) => fields[`L${44 + index}`] = byte);
+		NR_TAG.forEach((byte, index) => fields[`L${40 + index}`] = byte);
+		leBytes(ink, 6).forEach((byte, index) => fields[`L${60 + index}`] = byte);
+		leBytes(this.pageId, 4).forEach((byte, index) => fields[`L${67 + index}`] = byte);
+		leBytes(this.aid, 4).forEach((byte, index) => fields[`L${71 + index}`] = byte);
+		for (const [name, chain] of Object.entries(DIGEST_CHAINS)) {
+			const written = chainBytes(chain, digests[name]);
+			chain.slots.forEach((slot, index) => fields[slot] = written[index]);
+		}
+		return fields;
+	}
+	/**
+	* 为一次请求算出 `a_bogus`。
+	* @param query - 即将发出的 query 串，不含 `a_bogus` 自身
+	* @param options - body / Content-Type / 时钟
+	* @returns `a_bogus` 的值
+	*/
+	getValue(query, options = {}) {
+		const body = (options.contentType ?? "").toLowerCase().includes("multipart/form-data") ? "" : options.body ?? "";
+		const now = options.nowMs ?? Date.now();
+		if (now < 17218368e5) throw new Error(`时钟早于 a_bogus 纪元：${now}`);
+		const fields = this.fields(query, body, now);
+		const version = [...maskPair(SDK_VERSION.slice(0, 2), this.rng), ...maskPair(SDK_VERSION.slice(2, 4), this.rng, {
+			low: probeNoise(this.rng),
+			high: tripwireNoise(this.rng)
+		})];
+		let checksum = 0;
+		for (const byte of version) checksum ^= byte;
+		for (const name of FIELD_ORDER) checksum ^= fields[name];
+		const bodyBytes = FIELD_ORDER.map((name) => fields[name]);
+		bodyBytes.push(...jsBytes(this.browserInfo));
+		bodyBytes.push(...jsBytes(`${now + 3 & 255},`));
+		bodyBytes.push(checksum);
+		const header = maskPair(HEADER_MAGIC, this.rng, { high: headerNoise(this.userAgent, this.rng) });
+		const frame = expandNoise(bodyBytes, this.rng);
+		const sealed = rc4([211], [...version, ...frame]);
+		return encodeBase64([...header, ...sealed], "s4");
+	}
+};
+/** 这些毛病意味着这串东西**根本不是** a_bogus，而不是「内容出乎意料」 */
+const DECODE_PROBLEMS = /* @__PURE__ */ new Set([
+	"alphabet",
+	"length not a multiple of four",
+	"payload too short"
+]);
+/**
+* `problem` 是否表示「不是 a_bogus」而非「内容不符预期」。
+* @param problem - {@link structureError} 的返回
+* @returns 是否属于格式性失败
+*/
+const isDecodeProblem = (problem) => DECODE_PROBLEMS.has(problem ?? "");
+/**
+* `value` 第一处不满足 a_bogus 格式的地方，全都满足时返回 `null`。
+*
+* 这里每一条检查都由算法本身固定，所以两个都正确的实现无论噪声多不同，都会在这些
+* 检查上一致。**故意不检查长度**：长度跟着几何串走，两个都对但屏幕不同的浏览器就是
+* 会不一样。
+*
+* 最后一条检查才是值得拥有的那条。校验和是对载荷里本身就有的一些字段算的，所以能通过
+* 它的签名，必然是由一个在整套布局上与我们一致的实现装配出来的——版本块、五十槽置换、
+* 噪声展开、以及那个密码。不是真算法，凑不出一个。
+* @param value - 待检查的签名
+* @param alphabet - 字母表，默认 `s4`
+* @returns 问题标识或 `null`
+*/
+const structureError = (value, alphabet = "s4") => {
+	const body = value.replace(/=+$/, "");
+	const table = ALPHABETS[alphabet];
+	if (!body || body.includes("=") || [...body].some((char) => !table.includes(char))) return "alphabet";
+	if (value.length % 4) return "length not a multiple of four";
+	const payload = decodeBase64(value, alphabet);
+	if (payload.length < 80) return "payload too short";
+	if (unmaskPair(payload.slice(0, 4)).join(",") !== HEADER_MAGIC.join(",")) return "header magic";
+	const plain = rc4([211], payload.slice(4));
+	const version = plain.slice(0, 8);
+	const frame = plain.slice(8);
+	if (unmaskPair(version.slice(0, 4)).join(",") !== SDK_VERSION.slice(0, 2).join(",")) return "sdk version";
+	if (unmaskPair(version.slice(4, 8)).join(",") !== SDK_VERSION.slice(2, 4).join(",")) return "sdk version";
+	const unpacked = collapseNoise(frame);
+	if (unpacked.length < FIELD_ORDER.length + 1) return "frame too short";
+	const fields = {};
+	FIELD_ORDER.forEach((name, index) => fields[name] = unpacked[index]);
+	const infoLength = fields.L79 | fields.L80 << 8;
+	const tailLength = fields.L84 | fields.L85 << 8;
+	const end = FIELD_ORDER.length + infoLength + tailLength;
+	if (end + 1 > unpacked.length) return "declared lengths overrun the frame";
+	if (unpacked.length - (end + 1) > 2) return "declared lengths leave a tail";
+	let checksum = 0;
+	for (const byte of version) checksum ^= byte;
+	for (const name of FIELD_ORDER) checksum ^= fields[name];
+	if (unpacked[end] !== checksum) return "checksum";
+	return null;
+};
+/**
+* 把一份 `a_bogus` 拆开。用于诊断与测试，不用于签名。
+*
+* 这是证明算法正确的那个函数：拿浏览器产出的签名跑一遍，它会还原出那个浏览器的屏幕
+* 尺寸、抖音自己的 `aid`、以及与旁边那个 `timestamp` 参数吻合的时钟。
+* @param value - 待拆解的签名
+* @param alphabet - 字母表，默认 `s4`
+* @returns 可还原的字段
+*/
+const decode = (value, alphabet = "s4") => {
+	const problem = structureError(value, alphabet);
+	if (problem !== null) throw new Error(`不是一份格式良好的 a_bogus：${problem}`);
+	const payload = decodeBase64(value, alphabet);
+	const plain = rc4([211], payload.slice(4));
+	const unpacked = collapseNoise(plain.slice(8));
+	const fields = {};
+	FIELD_ORDER.forEach((name, index) => fields[name] = unpacked[index]);
+	const littleEndian = (first, count) => {
+		let total = 0;
+		for (let index = 0; index < count; index++) total += fields[`L${first + index}`] * 2 ** (8 * index);
+		return total;
+	};
+	const infoLength = fields.L79 | fields.L80 << 8;
+	const tailLength = fields.L84 | fields.L85 << 8;
+	const start = FIELD_ORDER.length;
+	const asText = (bytes) => new TextDecoder("utf-8", { fatal: false }).decode(Uint8Array.from(bytes));
+	return {
+		headerMagic: unmaskPair(payload.slice(0, 4)),
+		sdkVersion: [...unmaskPair(plain.slice(0, 4)), ...unmaskPair(plain.slice(4, 8))],
+		nowMs: littleEndian(29, 6),
+		inkMs: littleEndian(60, 6),
+		pageId: littleEndian(67, 4),
+		aid: littleEndian(71, 4),
+		envFlags: fields.L35,
+		detectFlags: littleEndian(44, 4),
+		callBucket: fields.L27,
+		tripwire: fields.L66,
+		browserInfo: asText(unpacked.slice(start, start + infoLength)),
+		tail: asText(unpacked.slice(start + infoLength, start + infoLength + tailLength)),
+		fields
+	};
+};
+/**
+* 兼容入口：给一条完整 URL 和一个 UA，返回 `a_bogus` 的值。
+*
+* 与旧实现的签名一致，所以 `sign/index.ts` 与 legacy 那个类不用改调用方式。
+* 需要控制时钟、几何串或随机源时用 {@link ABogus}。
+* @param url - 待签名的完整 URL
+* @param userAgent - 发起请求用的 User-Agent
+* @param options - 透传给 {@link ABogus} 与 {@link ABogus.getValue} 的选项
+* @returns `a_bogus` 的值
+*/
+var a_bogus_default = (url, userAgent, options = {}) => new ABogus(userAgent, options).getValue(new URLSearchParams(new URL(url).search).toString(), options);
+//#endregion
+//#region src/platforms/douyin/sign/tokens.ts
+/**
+* 假 msToken 的字符表，逐字符照抄 V4 的 `gen_random_str`。
+*
+* A-Z + a-z + 0-9 + `+-` 正好 64 个，拼出来就是标准 base64 的形状 ——
+* 假的 msToken 唯一要像真的地方就是形状。抄错表就毁在这上面：
+* 一个永远不含 `j`、中间还夹着 `=` 的 token，形状不对。
+*/
+const MS_TOKEN_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
+/** 抖音假 msToken 的长度（`==` 后缀之前那一段） */
+const DOUYIN_MS_TOKEN_LENGTH = 126;
+/** 真 msToken 回包的长度，不在其中说明接口变了形，值不该信 */
+const DOUYIN_MS_TOKEN_SIZES = [120, 128];
+/**
+* 本地生成的假 msToken。
+*
+* 平台对一部分端点认它、另一部分不认。原实现把它当作真接口失败时的兜底，
+* 调用方应当知道拿到的是哪一个（原实现只返回 token，降级和健康长得一模一样）。
+*
+* @param length - `==` 之前的长度，默认 {@link DOUYIN_MS_TOKEN_LENGTH}
+* @param options - `rng` / `suffix` 注入点
+* @returns `length` 个字符表内字符 + `suffix`
+*/
+const genFalseMsToken = (length = 126, options = {}) => {
+	const { rng = Math.random, suffix = "==" } = options;
+	let token = "";
+	for (let index = 0; index < length; index++) token += MS_TOKEN_ALPHABET[Math.trunc(rng() * 64)];
+	return token + suffix;
+};
+/** `verify_fp` / `s_v_web_id` 随机半段用的字符表（62 个：数字 + 大小写字母） */
+const VERIFY_FP_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/** 36 位尾巴里下划线所在的下标，构成 UUID 的 8-4-4-4-12 分段 */
+const VERIFY_FP_SEPARATORS = [
+	8,
+	13,
+	18,
+	23
+];
+/** 尾巴总长度 */
+const VERIFY_FP_LENGTH = 36;
+/**
+* 36 进制转换（照抄 Python 的 `_to_base36`，不用 `Number#toString(36)`）。
+*
+* 两者对非负整数结果一致，但 Python 那版对 `<= 0` 返回 `"0"` 而不是 `"-..."` ——
+* 自实现是把这条边界一起搬过来，省得以后有人换个入参就踩到差异。
+*
+* @param value - 非负整数
+* @returns 36 进制小写字符串
+*/
+const toBase36 = (value) => {
+	if (value <= 0) return "0";
+	let rest = Math.trunc(value);
+	let digits = "";
+	while (rest > 0) {
+		const remainder = rest % 36;
+		digits = (remainder < 10 ? String(remainder) : String.fromCharCode(97 + remainder - 10)) + digits;
+		rest = Math.trunc(rest / 36);
+	}
+	return digits;
+};
+/**
+* 生成一个 `verify_fp`。
+*
+* 形状：`verify_<毫秒时间戳的 36 进制>_<36 位 UUID v4 骨架>` —— 尾巴的下划线在
+* 8/13/18/23，下标 14 恒为 `4`，下标 19 是变体位。
+*
+* 随机数只在**非固定位**上消耗：四个下划线和版本位那 5 个下标跳过不抽签，
+* 所以一条尾巴正好抽 31 次，抽签顺序按下标升序 —— 与 Python 逐次对齐，
+* 注入同一串均匀数才能得到同一串字符。
+*
+* @param options - `nowMs` / `rng` 注入点
+* @returns 可直接当作 `verifyFp` / `s_v_web_id` cookie 的值
+*/
+const genVerifyFp = (options = {}) => {
+	const { nowMs = Date.now(), rng = Math.random } = options;
+	const alphabetSize = 62;
+	const tail = new Array(36).fill("");
+	for (const index of VERIFY_FP_SEPARATORS) tail[index] = "_";
+	tail[14] = "4";
+	for (let index = 0; index < 36; index++) {
+		if (tail[index]) continue;
+		const position = Math.trunc(rng() * alphabetSize);
+		tail[index] = VERIFY_FP_ALPHABET[index === 19 ? 3 & position | 8 : position];
+	}
+	return `verify_${toBase36(nowMs)}_${tail.join("")}`;
+};
+/**
+* `s_v_web_id` 与 `verify_fp` 同形状、同算法，只是 cookie 名不同。
+*
+* @param options - `nowMs` / `rng` 注入点
+* @returns 与 {@link genVerifyFp} 同构的值
+*/
+const genSVWebId = (options = {}) => genVerifyFp(options);
+/**
+* 拼上报接口的 JSON 请求体。
+*
+* 字段顺序照 Python 的 dict：magic → version → dataType → strData → tspFromClient。
+* 与 Python 唯一的差别是空白：`json.dumps` 默认带 `", "` / `": "` 分隔符，
+* `JSON.stringify` 是紧凑的；服务端按 JSON 解析，不看空白。
+*
+* @param spec - 上报接口的静态参数
+* @param timestampMs - 客户端时间戳（`tspFromClient`），默认 `Date.now()`
+* @returns 请求体字符串
+*/
+const msTokenPayload = (spec, timestampMs = Date.now()) => JSON.stringify({
+	magic: spec.magic,
+	version: spec.version,
+	dataType: spec.dataType,
+	strData: spec.strData,
+	tspFromClient: timestampMs
+});
+/** ttwid 注册接口（两个平台同域，只有 body 不同） */
+const TTWID_REGISTER_URL = "https://ttwid.bytedance.com/ttwid/union/register/";
+/** 抖音访客 ttwid 的注册体，不含任何凭证 */
+const DOUYIN_TTWID_PAYLOAD = {
+	region: "cn",
+	aid: 1768,
+	needFid: false,
+	service: "www.ixigua.com",
+	migrate_info: {
+		ticket: "",
+		source: "node"
+	},
+	cbUrlProtocol: "https",
+	union: true
+};
+/** 抖音访客 ttwid 注册：`POST {url}`，body 用 `data` */
+const DOUYIN_TTWID = {
+	url: TTWID_REGISTER_URL,
+	data: JSON.stringify(DOUYIN_TTWID_PAYLOAD)
+};
+//#endregion
+export { a_bogus_default as A, isDecodeProblem as B, FORTNIGHT_EPOCH_MS as C, SALT as D, PAYLOAD_KEY as E, decode as F, userAgentDigest as G, rc4 as H, decodeBase64 as I, sm3Hexdigest as J, SM3_IV as K, digestOf as L, buildBrowserInfo as M, canary as N, SDK_VERSION as O, chainBytes as P, digestWith as R, FIELD_ORDER as S, PAGE_ID as T, structureError as U, jsBytes as V, unmaskPair as W, sm3ToArray as Y, CALL_BUCKET as _, MS_TOKEN_ALPHABET as a, DIGEST_CHAINS as b, VERIFY_FP_LENGTH as c, genVerifyFp as d, msTokenPayload as f, ALPHABETS as g, AID as h, DOUYIN_TTWID_PAYLOAD as i, browserInfoFromScreen as j, TRIPWIRE_LOCKED as k, genFalseMsToken as l, ABogus as m, DOUYIN_MS_TOKEN_SIZES as n, TTWID_REGISTER_URL as o, toBase36 as p, sm3Hash as q, DOUYIN_TTWID as r, VERIFY_FP_ALPHABET as s, DOUYIN_MS_TOKEN_LENGTH as t, genSVWebId as u, DEFAULT_BROWSER_INFO as v, HEADER_MAGIC as w, ENV_FLAGS as x, DETECT_FLAGS as y, encodeBase64 as z };