@ikenxuan/amagi 7.0.0-beta.7 → 7.0.0-beta.8

package/dist/he-CuCIF0C7.cjs

@@ -0,0 +1,3898 @@
+//#region src/utils/md5.ts
+/**
+* 纯 TypeScript 的 MD5（RFC 1321），不依赖任何运行环境内置模块。
+*
+* ## 为什么不用 `node:crypto`
+*
+* MD5 出现在三处签名里（抖音 X-Bogus、抖音 `x-secsdk-web-signature`、B站 `w_rid`），
+* 而签名验证工具要在**浏览器**里跑 `@ikenxuan/amagi/signing` 这份代码 —— 页面存在的
+* 意义是证明实现本身还是对的，所以实现必须能进浏览器。`node:crypto` 进不去，
+* 这里就是那份「同一份代码」的MD5。
+*
+* 只给签名算法用。MD5 早已不具密码学安全性，不要把它当通用哈希用。
+*
+* ## 边界
+*
+* - 输入按字节处理；字符串先用 `TextEncoder` 转 UTF-8（与 `node:crypto`
+*   `createHash('md5')` 默认的 `'utf8'` 编码一致，两边输出逐字节相同）。
+* - 长度计数用两次 `* 4294967296` 进位模拟 64 位比特长度，超出 `Number.MAX_SAFE_INTEGER`
+*   字节的输入不受支持（签名场景不可能出现）。
+*/
+/** 每个 round 使用的 32 位常量，来自 sin 函数绝对值的整数部分（RFC 1321 附录） */
+const T = [
+	3614090360,
+	3905402710,
+	606105819,
+	3250441966,
+	4118548399,
+	1200080426,
+	2821735955,
+	4249261313,
+	1770035416,
+	2336552879,
+	4294925233,
+	2304563134,
+	1804603682,
+	4254626195,
+	2792965006,
+	1236535329,
+	4129170786,
+	3225465664,
+	643717713,
+	3921069994,
+	3593408605,
+	38016083,
+	3634488961,
+	3889429448,
+	568446438,
+	3275163606,
+	4107603335,
+	1163531501,
+	2850285829,
+	4243563512,
+	1735328473,
+	2368359562,
+	4294588738,
+	2272392833,
+	1839030562,
+	4259657740,
+	2763975236,
+	1272893353,
+	4139469664,
+	3200236656,
+	681279174,
+	3936430074,
+	3572445317,
+	76029189,
+	3654602809,
+	3873151461,
+	530742520,
+	3299628645,
+	4096336452,
+	1126891415,
+	2878612391,
+	4237533241,
+	1700485571,
+	2399980690,
+	4293915773,
+	2240044497,
+	1873313359,
+	4264355552,
+	2734768916,
+	1309151649,
+	4149444226,
+	3174756917,
+	718787259,
+	3951481745
+];
+/** 每步循环左移的位数（RFC 1321 的 s 表） */
+const S = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+];
+const rotateLeft = (value, shift) => (value << shift | value >>> 32 - shift) >>> 0;
+/** 小端序读一个 32 位字 */
+const readWordLE = (bytes, offset) => (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+/**
+* 计算一份消息的 MD5，返回 32 位小写十六进制。
+*
+* @param input - 字节序列，或先按 UTF-8 编码的字符串
+* @returns 32 个小写十六进制字符
+*/
+const md5Hex = (input) => {
+	const message = typeof input === "string" ? new TextEncoder().encode(input) : input;
+	const byteLength = message.length;
+	const paddedLength = (byteLength + 8 >> 6) * 64 + 64;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(message);
+	padded[byteLength] = 128;
+	const bitLength = byteLength * 8;
+	padded[paddedLength - 8] = bitLength & 255;
+	padded[paddedLength - 7] = bitLength >>> 8 & 255;
+	padded[paddedLength - 6] = bitLength >>> 16 & 255;
+	padded[paddedLength - 5] = bitLength >>> 24 & 255;
+	const highBits = Math.floor(bitLength / 4294967296);
+	padded[paddedLength - 4] = highBits & 255;
+	let a0 = 1732584193;
+	let b0 = 4023233417;
+	let c0 = 2562383102;
+	let d0 = 271733878;
+	for (let chunk = 0; chunk < paddedLength; chunk += 64) {
+		const words = new Array(16);
+		for (let index = 0; index < 16; index++) words[index] = readWordLE(padded, chunk + index * 4);
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		for (let step = 0; step < 64; step++) {
+			let f;
+			let g;
+			if (step < 16) {
+				f = b & c | ~b & d;
+				g = step;
+			} else if (step < 32) {
+				f = d & b | ~d & c;
+				g = (5 * step + 1) % 16;
+			} else if (step < 48) {
+				f = b ^ c ^ d;
+				g = (3 * step + 5) % 16;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * step % 16;
+			}
+			const sum = a + f + T[step] + words[g] >>> 0;
+			const shifted = rotateLeft(sum, S[step]);
+			a = d;
+			d = c;
+			c = b;
+			b = b + shifted >>> 0;
+		}
+		a0 = a0 + a >>> 0;
+		b0 = b0 + b >>> 0;
+		c0 = c0 + c >>> 0;
+		d0 = d0 + d >>> 0;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(16);
+	for (const [index, word] of [
+		a0,
+		b0,
+		c0,
+		d0
+	].entries()) {
+		digest[index * 4] = word & 255;
+		digest[index * 4 + 1] = word >>> 8 & 255;
+		digest[index * 4 + 2] = word >>> 16 & 255;
+		digest[index * 4 + 3] = word >>> 24 & 255;
+	}
+	let hex = "";
+	for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+};
+//#endregion
+//#region src/platforms/bilibili/sign/wbi.ts
+/**
+* B站 wbi 签名器（实例级）。
+*
+* 两处实现要点：
+* - **走 transport**：`getNav` 用 `ctx.send` 发 `/nav`（`reason: 'prepare'`
+*   进 trace），与主请求走同一条路。
+* - **TTL 缓存在实例里**：keys 缓存挂在实例上，TTL 内连续签名只打一次 `/nav`。
+*   B站只有一个进程级实例（见下方类文档），所以这份缓存进程内共享。
+*
+* 签名算法本身（`mixinKeyEncTab` / `encWbi`）与旧版逐字一致。
+*/
+/** wbi 密钥的 TTL（毫秒）。30 分钟内复用缓存 */
+const WBI_TTL_MS = 18e5;
+/** 混合密钥编码表 */
+const mixinKeyEncTab = [
+	46,
+	47,
+	18,
+	2,
+	53,
+	8,
+	23,
+	32,
+	15,
+	50,
+	10,
+	31,
+	58,
+	3,
+	45,
+	35,
+	27,
+	43,
+	5,
+	49,
+	33,
+	9,
+	42,
+	19,
+	29,
+	28,
+	14,
+	39,
+	12,
+	38,
+	41,
+	13,
+	37,
+	48,
+	7,
+	16,
+	24,
+	55,
+	40,
+	61,
+	26,
+	17,
+	0,
+	1,
+	60,
+	51,
+	30,
+	4,
+	22,
+	25,
+	54,
+	21,
+	56,
+	59,
+	6,
+	63,
+	57,
+	62,
+	11,
+	36,
+	20,
+	34,
+	44,
+	52
+];
+/** 从 URL 末尾取文件名部分（去扩展名），得到 img_key / sub_key */
+const extractKey = (url) => url.slice(url.lastIndexOf("/") + 1, url.lastIndexOf("."));
+/**
+* 对 imgKey 和 subKey 进行字符顺序打乱编码。
+* @param orig - img_key + sub_key 拼接
+* @returns 32 位 mixin key
+*/
+const getMixinKey = (orig) => mixinKeyEncTab.map((n) => orig[n]).join("").slice(0, 32);
+/**
+* 按给定时间戳计算 wbi 签名 —— **验证工具与 {@link encWbi} 共用的唯一实现**。
+*
+* 不修改传入的 `params`；时钟由调用方注入，所以对一份已签名的 URL 重算
+* `w_rid` 时可以钉死它自己的 `wts`，逐字符复现。
+* @param params - 请求参数（不含 wts / w_rid）
+* @param img_key - 图片密钥
+* @param sub_key - 子密钥
+* @param wts - 秒级时间戳
+* @returns 签名产物
+*/
+const computeWbiSignature = (params, img_key, sub_key, wts) => {
+	const mixinKey = getMixinKey(img_key + sub_key);
+	const chr_filter = /[!'()*]/g;
+	const canonicalQuery = Object.keys({
+		...params,
+		wts
+	}).sort().map((key) => {
+		const value = (key === "wts" ? wts : params[key]).toString().replace(chr_filter, "");
+		return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+	}).join("&");
+	return {
+		wts,
+		w_rid: md5Hex(canonicalQuery + mixinKey),
+		canonicalQuery,
+		mixinKey
+	};
+};
+/**
+* 为请求参数计算 wbi 签名。
+* @param params - 请求参数（不含 wts / w_rid）
+* @param img_key - 图片密钥
+* @param sub_key - 子密钥
+* @returns `&wts=..&w_rid=..` 查询串
+*/
+const encWbi = (params, img_key, sub_key) => {
+	const curr_time = Math.round(Date.now() / 1e3);
+	Object.assign(params, { wts: curr_time });
+	const { wts, w_rid } = computeWbiSignature(params, img_key, sub_key, curr_time);
+	return `&wts=${wts}&w_rid=${w_rid}`;
+};
+/**
+* B站 wbi 签名器实例。
+*
+* 进程级共享一个：`steps.ts` 模块级建 `sharedWbi`，`wbi()` / `qtparam()` 与
+* `signers.ts` 的签名器表都复用它（`PLATFORM_RUNTIME` 模块求值时只装配一次）。
+* keys 缓存挂在这个实例上 —— TTL 内 `sign` 不会重复打 `/nav`，两条路共享同一份缓存。
+*/
+var WbiSigner = class {
+	ttlMs;
+	now;
+	nav;
+	/**
+	* @param ttlMs - keys 缓存有效期，默认 {@link WBI_TTL_MS}
+	* @param now - 时钟（可注入）
+	*/
+	constructor(ttlMs = WBI_TTL_MS, now = Date.now) {
+		this.ttlMs = ttlMs;
+		this.now = now;
+	}
+	/**
+	* 取 `/nav` 响应体（带 TTL 缓存）。
+	*
+	* 走 `ctx.send`（reason `'prepare'`）。
+	* @param ctx - 执行上下文（提供 send 与 cookie）
+	* @returns `/nav` 响应体
+	*/
+	async getNav(ctx) {
+		const cached = this.nav;
+		if (cached && this.now() - cached.fetchedAt < this.ttlMs) return cached.body;
+		const body = (await ctx.send({
+			method: "GET",
+			url: "https://api.bilibili.com/x/web-interface/nav",
+			headers: { cookie: ctx.cookie }
+		}, "prepare")).body;
+		this.nav = {
+			body,
+			fetchedAt: this.now()
+		};
+		return body;
+	}
+	/** 从 `/nav` 响应体提取 wbi keys */
+	keysOf(body) {
+		const img = body.data?.wbi_img?.img_url;
+		const sub = body.data?.wbi_img?.sub_url;
+		if (!img || !sub) throw new Error("wbi 密钥获取失败：/nav 响应缺少 wbi_img");
+		return {
+			img_key: extractKey(img),
+			sub_key: extractKey(sub)
+		};
+	}
+	/**
+	* 签名器：给请求 URL 追加 `&wts=..&w_rid=..`。
+	*
+	* `sign: 'wbi'` 的端点（comments / userDynamicList / userSpaceInfo 等）用它。
+	* 首次调用会触发 `/nav` 前置请求（reason `'prepare'`），TTL 内复用。
+	* @param spec - 请求描述
+	* @param ctx - 执行上下文
+	* @returns 带 wbi 签名的请求描述
+	*/
+	sign = async (spec, ctx) => {
+		const nav = await this.getNav(ctx);
+		const { img_key, sub_key } = this.keysOf(nav);
+		const url = new URL(spec.url);
+		const params = {};
+		for (const [key, value] of url.searchParams.entries()) params[key] = value;
+		const query = encWbi(params, img_key, sub_key);
+		return {
+			...spec,
+			url: spec.url + query
+		};
+	};
+	/** 清空 keys 缓存（下次 sign 重新打 `/nav`）。测试隔离用。 */
+	reset() {
+		this.nav = void 0;
+	}
+};
+/** 创建一个 wbi 签名器实例（B站生产路径只在 `steps.ts` 建一个进程级 `sharedWbi`；测试可各建各的） */
+const createWbiSigner = (ttlMs, now) => new WbiSigner(ttlMs, now);
+//#endregion
+//#region src/contracts/cookie.ts
+/**
+* Cookie 契约。
+*
+* **全仓唯一的 cookie 解析与序列化实现。** 解析按 RFC 6265 的键值语义：
+* 名字大小写敏感、值取第一个 `=` 之后的全部内容、不做 URL 解码。
+*
+* `contracts/` 是零依赖叶子层，本文件不 import 任何模块。
+*/
+/**
+* 解析 `name=value; name=value` 形式的 cookie 串。
+*
+* 规则：
+* - 以第一个 `=` 分割，所以值里可以含 `=`（如 base64）。
+* - 名与值两端去空白。
+* - 名为空、或整段没有 `=` 的片段直接跳过。
+* - 同名多次出现时**后者覆盖前者**。
+* - 值不做 URL 解码 —— 签名依赖原始字节，解码会改变签名输入。
+*
+* cookie 名按 RFC 6265 是**大小写敏感**的，因此本函数不做任何大小写归一化。
+* 这与 header 名大小写不敏感（见 `AmagiHeaders`）是两件不同的事。
+* @param cookieString - cookie 串，`undefined` / `null` / 空串都安全
+* @returns 名 → 值的普通对象，无有效项时是空对象
+*/
+const parseCookie = (cookieString) => {
+	const result = {};
+	if (!cookieString) return result;
+	for (const pair of cookieString.split(";")) {
+		const index = pair.indexOf("=");
+		if (index <= 0) continue;
+		const name = pair.slice(0, index).trim();
+		if (!name) continue;
+		result[name] = pair.slice(index + 1).trim();
+	}
+	return result;
+};
+/**
+* 取单条 cookie 的值。
+*
+* **按名精确匹配**，不是子串匹配 ——
+* `getCookieValue('xa1=WRONG; a1=RIGHT', 'a1')` 返回 `'RIGHT'` 而不是 `'WRONG'`。
+* @param cookieString - 完整 cookie 串
+* @param name - cookie 名，大小写敏感
+* @returns 值；不存在时返回 `undefined`
+*/
+const getCookieValue = (cookieString, name) => {
+	if (!cookieString || !name) return void 0;
+	return parseCookie(cookieString)[name];
+};
+//#endregion
+//#region src/platforms/douyin/sign/secsdkWebSign.ts
+/**
+* 抖音主站 `x-secsdk-web-signature` 纯算实现（TypeScript 移植）
+*
+* 移植自 cv-cat/DouYin_Spider `utils/secsdk_web_sign.py`，算法与常量按该实现逐条对齐。
+*
+* ## 算法
+*
+* ```text
+* plain     = {uifid}_{timestamp}_{WEBSIGN_CONST}_{canonical_query}
+* signature = md5(plain) 的 32 位小写十六进制
+* ```
+*
+* `WEBSIGN_CONST` 是 secsdk VMP 常量池里的写死盐，与账号 / 会话无关。
+*
+* ## canonical_query 规范化规则
+*
+* - 保持原始参数顺序，**不排序**；重复参数原样保留。
+* - 每个 value 先解码（`+`→空格、`%XX`→字节）再用 `encodeURIComponent` 重编码。
+* - key **只解码、不重编码**。
+* - 无等号的裸参数补成 `k=`。
+* - `&timestamp={ts}` 追加到 query 末尾后再参与哈希。
+* - query 里没有 `uifid` 时，从 `UIFID` cookie 取值追加到末尾再签。
+*
+* ## 重要
+*
+* 签名算的是**规范化后的 query**，服务端也按收到的 query 校验，所以必须发送
+* {@link signSecsdkWebUrl} 返回的 URL，不能拿原始 URL 直接发。
+*
+* 签名绑 query、**不绑 path**（本项目实测：同一份 query 换 path 仍然 200）。
+*
+* @module platform/douyin/secsdkWebSign
+*/
+/** secsdk VM 常量池里的固定盐（与账号 / 会话无关） */
+const WEBSIGN_CONST = "A96D855A08C0A9707F8BEF0D9A527E4E";
+/** 签名参数名 */
+const SECSDK_SIG_KEY = "x-secsdk-web-signature";
+/** 时间戳参数名 */
+const SECSDK_TS_KEY = "timestamp";
+/** 走 secsdk 签名的 GET 接口路径（来自 SDK 的 webSign 策略配置） */
+const PROTECTED_PATHS_GET = [
+	"/aweme/v1/web/aweme/detail/",
+	"/aweme/v1/web/aweme/post/",
+	"/aweme/v1/web/aweme/favorite/",
+	"/aweme/v1/web/aweme/listcollection/",
+	"/aweme/v1/web/mix/aweme/",
+	"/aweme/v1/web/tab/feed/",
+	"/aweme/v1/web/mix/list/",
+	"/aweme/v1/web/music/aweme/",
+	"/aweme/v1/web/music/list/",
+	"/aweme/v1/web/mix/detail/",
+	"/aweme/v1/web/mix/listcollection/",
+	"/aweme/v1/web/music/detail/",
+	"/aweme/v1/web/collects/list/",
+	"/aweme/v1/web/collects/video/list/"
+];
+/** 走 secsdk 签名的 POST 接口路径 */
+const PROTECTED_PATHS_POST = [
+	"/aweme/v1/web/aweme/detail/",
+	"/aweme/v1/web/aweme/post/",
+	"/aweme/v1/web/aweme/favorite/",
+	"/aweme/v1/web/aweme/listcollection/",
+	"/aweme/v1/web/mix/aweme/",
+	"/aweme/v1/web/tab/feed/"
+];
+const HEX_PAIR = /^[0-9A-Fa-f]{2}$/;
+/**
+* 宽容的百分号解码，等价于 Python `urllib.parse.unquote(..., errors='replace')`：
+* 合法的 `%XX` 解成字节，非法的 `%` 原样保留，最后按 UTF-8 解码（坏字节 → U+FFFD）。
+*
+* 不能直接用 `decodeURIComponent` —— 它遇到 `100%` 这种孤立百分号会抛异常，
+* 而 SDK 的行为是把它当字面量留下（`100%` → 签成 `100%25`）。
+*
+* @param input - 待解码字符串
+* @returns 解码后的字符串
+*/
+const percentDecodeLoose = (input) => {
+	if (!input.includes("%")) return input;
+	const bytes = [];
+	let i = 0;
+	while (i < input.length) {
+		if (input[i] === "%" && HEX_PAIR.test(input.slice(i + 1, i + 3))) {
+			bytes.push(parseInt(input.slice(i + 1, i + 3), 16));
+			i += 3;
+			continue;
+		}
+		for (const byte of new TextEncoder().encode(input[i])) bytes.push(byte);
+		i += 1;
+	}
+	return new TextDecoder().decode(new Uint8Array(bytes));
+};
+/**
+* 等价于 Python `unquote_plus`：先把 `+` 当空格，再做百分号解码。
+*
+* @param input - 待解码字符串
+* @returns 解码后的字符串
+*/
+const unquotePlusLoose = (input) => percentDecodeLoose(input.includes("+") ? input.replace(/\+/g, " ") : input);
+/**
+* 按 SDK 规则规范化 query 字符串：顺序不变，value 解码后用 `encodeURIComponent` 重编码，
+* key 只解码不重编码，无等号的裸参数补成 `k=`。
+*
+* @param query - 原始 query 字符串（不含 `?`）
+* @returns 规范化后的 query 字符串
+*/
+const canonicalQuery = (query) => {
+	const parts = [];
+	for (const pair of query.split("&")) {
+		if (!pair) continue;
+		const eq = pair.indexOf("=");
+		const rawKey = eq === -1 ? pair : pair.slice(0, eq);
+		const rawValue = eq === -1 ? "" : pair.slice(eq + 1);
+		parts.push(`${unquotePlusLoose(rawKey)}=${encodeURIComponent(unquotePlusLoose(rawValue))}`);
+	}
+	return parts.join("&");
+};
+/**
+* 拆成 `[base, query]`，并剥掉已有的 `timestamp` / 签名字段，保证可重复调用。
+*
+* @param url - 完整 URL
+* @returns `[base, query]` 二元组
+*/
+const splitUrl = (url) => {
+	const mark = url.indexOf("?");
+	if (mark === -1) return [url, ""];
+	return [url.slice(0, mark), url.slice(mark + 1).split("&").filter((pair) => {
+		if (!pair) return false;
+		const name = pair.split("=", 1)[0];
+		return name !== "timestamp" && name !== "x-secsdk-web-signature";
+	}).join("&")];
+};
+/**
+* secsdk 找访客 id 时认的 cookie 名，**按此顺序取第一个非空值**。
+*
+* 抖音自己铸造访客身份时落的是 `UIFID_TEMP`，`UIFID` 是同一个值的另一种拼写；
+* SDK 六种都认。只认 `UIFID=` 一种会漏掉只有 `UIFID_TEMP` 的 cookie —— 那种 cookie
+* 明明带着可用的访客 id，却被判成「没有」，于是整条 secsdk 加签被跳过。
+*
+* 清单为线上实测的 SDK 查找顺序。
+*/
+const UIFID_COOKIE_NAMES = [
+	"uifid",
+	"uifid_temp",
+	"uifidtemp",
+	"UIFID",
+	"UIFID_TEMP",
+	"UIFIDTEMP"
+];
+/**
+* 从 cookie 字符串里取访客 id。
+*
+* 按 {@link UIFID_COOKIE_NAMES} 的顺序取第一个非空值。用 `getCookieValue` 按名精确
+* 匹配，所以 `UIFID_TEMP=temp; UIFID=real` 不会把 `UIFID` 读成 `temp`
+* （cookie 名大小写敏感，`getCookieValue` 也不做归一化）。
+*
+* @param cookie - cookie 字符串
+* @returns 访客 id，取不到时返回空串
+*/
+const extractUifidFromCookie = (cookie) => {
+	if (!cookie) return "";
+	for (const name of UIFID_COOKIE_NAMES) {
+		const value = getCookieValue(cookie, name)?.trim();
+		if (value) return value;
+	}
+	return "";
+};
+/**
+* 判断该 path 是否需要 secsdk 加签（依据 SDK 的 webSign 策略配置）。
+*
+* @param path - URL 的 pathname
+* @param method - HTTP 方法，默认 `GET`
+* @returns 是否需要加签
+*/
+const isSecsdkProtected = (path, method = "GET") => {
+	return (String(method).toUpperCase() === "POST" ? PROTECTED_PATHS_POST : PROTECTED_PATHS_GET).includes(path);
+};
+/**
+* 计算 `x-secsdk-web-signature`。
+*
+* @param url - 完整 API URL（scheme+host+path+query）。已带 `timestamp` /
+*              `x-secsdk-web-signature` 时会自动剥除，可重复调用。
+* @param options - 时间戳与 uifid 兜底值
+* @returns 时间戳、签名与**实际应当发送**的规范化 query
+*/
+const signSecsdkWebQuery = (url, options = {}) => {
+	const ts = Math.trunc(options.ts ?? Date.now() / 1e3);
+	const [, rawQuery] = splitUrl(url);
+	let canon = canonicalQuery(rawQuery);
+	if (!canon.split("&").filter(Boolean).map((pair) => pair.split("=", 1)[0]).includes("uifid") && options.uifid) {
+		const appended = `uifid=${encodeURIComponent(options.uifid)}`;
+		canon = canon ? `${canon}&${appended}` : appended;
+	}
+	const signedQuery = canon ? `${canon}&${SECSDK_TS_KEY}=${ts}` : `${SECSDK_TS_KEY}=${ts}`;
+	let uifidValue = "";
+	for (const pair of signedQuery.split("&")) if (pair.startsWith("uifid=")) {
+		uifidValue = unquotePlusLoose(pair.slice(6));
+		break;
+	}
+	if (!uifidValue && options.uifid) uifidValue = options.uifid;
+	const plain = `${uifidValue}_${ts}_${WEBSIGN_CONST}_${signedQuery}`;
+	return {
+		ts,
+		signature: md5Hex(plain),
+		signedQuery
+	};
+};
+/**
+* 返回可直接发送的完整 URL（规范化 query + timestamp + 签名）。
+*
+* 服务端按收到的 query 校验签名，所以必须发这个返回值，不能拿原始 URL 直接发。
+*
+* @param url - 完整 API URL
+* @param options - 时间戳与 uifid 兜底值
+* @returns 带签名的完整 URL
+*/
+const signSecsdkWebUrl = (url, options = {}) => {
+	const [base] = splitUrl(url);
+	const { signature, signedQuery } = signSecsdkWebQuery(url, options);
+	return `${base}?${signedQuery}&${SECSDK_SIG_KEY}=${signature}`;
+};
+/**
+* 对受保护接口补上 secsdk 签名；path 不在策略表里时原样返回。
+*
+* 这是给取数层用的唯一入口 —— 无条件套在 URL 上即可，不需要调用方判断端点。
+*
+* ## 取不到访客 id 时**整个不加签**
+*
+* 取不到就拿空串继续算的话，受保护端点会收到一个「签了名、但签的是一个不存在的
+* 访客」的请求，抖音回 `403 Uifid Not Found` —— 且会被判成风控，**一个签名缺参的
+* 问题看起来像账号被风控**。不加签则表外端点照常工作，表内端点由平台自己点名
+* `uifid`，比自造错误有信息量。与 `webid` 的纪律同源：不传安全，传错致命。
+*
+* 访客 id **算不出来**：它由 secsdk 在真实浏览器里向铸造接口申请，所以这里只能
+* 取、不能造。扫码登录拿回来的是身份 cookie（`sessionid` 那一族），不含访客 id，
+* 这是「刚登录完反而被拦」的成因。
+*
+* @param url - 完整 API URL（应当是**最后一步**，即 a_bogus 等参数都已拼好之后）
+* @param options - cookie / uifid / method / ts
+* @returns 需要加签且拿到访客 id 的返回带签名的 URL，否则原样返回
+*/
+const applySecsdkWebSign = (url, options = {}) => {
+	let pathname;
+	try {
+		pathname = new URL(url).pathname;
+	} catch {
+		return url;
+	}
+	if (!isSecsdkProtected(pathname, options.method)) return url;
+	const uifid = options.uifid || extractUifidFromCookie(options.cookie);
+	if (!uifid) return url;
+	return signSecsdkWebUrl(url, {
+		ts: options.ts,
+		uifid
+	});
+};
+//#endregion
+//#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$1 = 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$1 = (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$1(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$1([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$1([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$1([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)
+};
+/**
+* 拆开一个 `verify_fp` / `s_v_web_id`。
+*
+* 这类值的唯一真实载荷就是**生成时刻**（`verify_<36 进制毫秒>_<36 位 UUID v4 骨架>`），
+* 其余 31 个字符是纯随机。骨架的四个位置常量（分隔符、版本位、变体位）加上字母表
+* 约束构成指纹；时钟能原样读回，所以「这条 verify_fp 是什么时候生成的」是可判定的。
+*
+* 它**不能**辨别真假：假值的形状目标就是与真值一致（见 {@link genVerifyFp}）。
+* @param value - 待检查的值
+* @returns 拆解结果；骨架不符时 `problems` 非空
+*/
+const decodeVerifyFp = (value) => {
+	const problems = [];
+	if (!value.startsWith("verify_")) return {
+		timestampMs: 0,
+		problems: ["prefix"]
+	};
+	const body = value.slice(7);
+	const firstUnderscore = body.indexOf("_");
+	if (firstUnderscore === -1) return {
+		timestampMs: 0,
+		problems: ["prefix"]
+	};
+	const timestamp36 = body.slice(0, firstUnderscore);
+	const tail = body.slice(firstUnderscore + 1);
+	if (tail.length !== 36) return {
+		timestampMs: 0,
+		problems: ["tail length"]
+	};
+	if (!/^[0-9a-z]+$/.test(timestamp36)) return {
+		timestampMs: 0,
+		problems: ["prefix"]
+	};
+	for (const index of VERIFY_FP_SEPARATORS) if (tail[index] !== "_") problems.push("separators");
+	if (tail[14] !== "4") problems.push("version");
+	const variant = tail[19];
+	if (variant === void 0 || !"89AB".includes(variant)) problems.push("variant");
+	for (let index = 0; index < tail.length; index++) {
+		if (VERIFY_FP_SEPARATORS.includes(index)) continue;
+		if (!"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".includes(tail[index])) {
+			problems.push("alphabet");
+			break;
+		}
+	}
+	const timestampMs = Number.parseInt(timestamp36, 36);
+	return {
+		timestampMs: Number.isNaN(timestampMs) ? 0 : timestampMs,
+		problems
+	};
+};
+//#endregion
+//#region src/platforms/douyin/sign/decode.ts
+/**
+* 把签名参数读回明文 —— 验证工具的解码层。
+*
+* 移植自 Douyin_TikTok_Download_API 的 `signing/native/decoding.py`（Apache-2.0）。
+* 存在的理由只有一个：**证明签名实现还是对的**。
+*
+* ## 为什么需要它
+*
+* 抖音对签名是抽样校验的，所以「请求成功」证明不了任何事。唯一能证伪一个常量的办法，
+* 是把真实签名拆开看。旧实现用错盐值（`cus`）活了两年没被发现，就是因为整套测试都是
+* 自证的——自生成快照、和被测量对象比自身、以及没有任何一条断言能证伪一个常量。
+*
+* 这个模块提供外部锚点：给它一份浏览器产出的签名，它会告诉你签名里封住的到底是什么，
+* 以及你手上的候选输入是不是它封的那一个。
+*
+* ## 「解码」在这里诚实地指三件不同的事
+*
+* 把它们混为一谈，就是这类工具开始撒谎的方式：
+*
+* - **可还原**：值就在载荷里，能原样取回。时钟、`aid`、`page_id`、屏幕几何串、
+*   版本串、调用计数。没有任何推断。
+* - **被绑定但不可还原**：载荷里带着某个东西的摘要——a_bogus 里是 query / body / UA
+*   各三个 SM3 字节。输入无法从摘要倒推出来，所以这个模块**从不假装能**。它做的是
+*   **校验**：给它一个候选值，它回答这个候选是不是签名封住的那一个，以及有多少位证据
+*   支持这个结论。这才是哈希真正的逆运算，而且比猜一个值有用得多——它把
+*   「我的请求被拒了」变成「我发的这个签名是对着另一条 URL 算的」。
+* - **根本没被计算**：`msToken` 与访客令牌由平台签发或随机抽出来，底下没有明文可找。
+*   说出这一点就是答案，而不是「没能给出答案」。
+*
+* 每个字段都携带自己属于哪一类，读者不会被留在「标签旁边那个数字是读出来的还是推出来的」
+* 这种猜测里。
+*
+* 这里没有任何东西用于签名。它只跑在调用方已经持有的值上，不碰网络、不消耗身份。
+*/
+/** 字段是什么。控制台按它上色，调用方也可以对它分支 */
+const KIND = {
+	/** 从载荷里直接读出，就是签名者放进去的东西 */
+	PLAIN: "plain",
+	/** 一个时钟，同时给出原始数字与 ISO-8601 时刻 */
+	TIME: "time",
+	/** 哈希或哈希的一个字节。输入不可还原——见 checks */
+	DIGEST: "digest",
+	/** 内部冗余。在这里重算，这正是解码得以自证的依据 */
+	CHECKSUM: "checksum",
+	/** SDK 对它自认为身处其中的页面所做的回报 */
+	ENVIRONMENT: "environment",
+	/** 每次捕获里都有、但含义未被确认的东西。命名它，而不是编造它 */
+	OPAQUE: "opaque"
+};
+/** 一个参数底下为什么没有明文 */
+const REASON = {
+	MALFORMED: "malformed",
+	NOT_COMPUTED: "not_computed",
+	ONE_WAY: "one_way",
+	UNKNOWN_PARAMETER: "unknown_parameter"
+};
+/** 候选输入是不是签名封住的那一个 */
+const CHECK = {
+	MATCH: "match",
+	DIFFERS: "differs",
+	NOT_SUPPLIED: "not_supplied"
+};
+/** 每条摘要链钉住输入的位数 */
+const CHAIN_BITS = 24;
+const FORTNIGHT_MS = 12096e5;
+/** 毫秒时钟转 ISO-8601 UTC；数字荒诞到解析不了时退回原样，因为那通常正是它最有意思的地方 */
+const instant = (milliseconds) => {
+	const date = new Date(milliseconds);
+	return Number.isNaN(date.getTime()) ? String(milliseconds) : date.toISOString().replace(".000Z", "Z");
+};
+/** 秒/毫秒时钟的字段构造器；X-Bogus 的解码层（`x_bogus.ts`）也用它，两份拆解结果同构 */
+const clockField = (name, milliseconds, detail) => ({
+	name,
+	value: `${milliseconds} (${instant(milliseconds)})`,
+	kind: KIND.TIME,
+	detail
+});
+const check = (name, expected, actual, covered) => expected.join(",") === actual.join(",") ? {
+	name,
+	status: CHECK.MATCH,
+	bits: CHAIN_BITS,
+	covered
+} : {
+	name,
+	status: CHECK.DIFFERS,
+	bits: CHAIN_BITS
+};
+/**
+* 拆开一份 `a_bogus`，并就调用方给出的候选值做校验。
+* @param value - `a_bogus` 的值
+* @param candidates - 候选的 query / body / User-Agent，给哪个校验哪个
+* @returns 拆解结果；格式不合法时 `recovered` 为 `false` 并给出 `reason`
+*/
+const decodeABogus = (value, candidates = {}) => {
+	const problem = structureError(value);
+	if (problem !== null) return {
+		parameter: "a_bogus",
+		platform: "douyin",
+		algorithm: "a_bogus",
+		recovered: false,
+		reason: `${REASON.MALFORMED}:${problem}`,
+		fields: [],
+		checks: [],
+		notes: []
+	};
+	const raw = decode(value);
+	const scalars = raw.fields;
+	const fortnights = scalars.L26;
+	const fields = [
+		{
+			name: "header_magic",
+			value: `[${raw.headerMagic.join(", ")}]`,
+			kind: KIND.PLAIN
+		},
+		{
+			name: "sdk_version",
+			value: raw.sdkVersion.join("."),
+			kind: KIND.PLAIN
+		},
+		clockField("now_ms", raw.nowMs),
+		clockField("ink_ms", raw.inkMs, "now_ms - 1，SDK 对自己的存活检查"),
+		{
+			name: "aid",
+			value: String(raw.aid),
+			kind: KIND.PLAIN
+		},
+		{
+			name: "page_id",
+			value: String(raw.pageId),
+			kind: KIND.PLAIN
+		},
+		{
+			name: "fortnights",
+			value: `${fortnights} (${instant(FORTNIGHT_EPOCH_MS + fortnights * FORTNIGHT_MS)})`,
+			kind: KIND.PLAIN,
+			detail: "自 a_bogus 纪元起的「两周」数"
+		},
+		{
+			name: "browser_info",
+			value: raw.browserInfo,
+			kind: KIND.ENVIRONMENT,
+			detail: "屏幕|可视区|…"
+		},
+		{
+			name: "tail",
+			value: raw.tail,
+			kind: KIND.PLAIN,
+			detail: "(now_ms + 3) & 0xFF"
+		},
+		{
+			name: "env_flags",
+			value: String(raw.envFlags),
+			kind: KIND.ENVIRONMENT
+		},
+		{
+			name: "detect_flags",
+			value: String(raw.detectFlags),
+			kind: KIND.ENVIRONMENT
+		},
+		{
+			name: "call_bucket",
+			value: String(raw.callBucket),
+			kind: KIND.ENVIRONMENT
+		},
+		{
+			name: "tripwire",
+			value: String(raw.tripwire),
+			kind: KIND.ENVIRONMENT
+		}
+	];
+	const inputByChain = {
+		query: candidates.query,
+		body: candidates.body,
+		user_agent: candidates.userAgent
+	};
+	const emptyBody = chainBytes(DIGEST_CHAINS.body, digestWith("", SALT));
+	const checks = [];
+	for (const [name, chain] of Object.entries(DIGEST_CHAINS)) {
+		const carried = chain.slots.map((slot) => scalars[slot]);
+		let detail = `${name} 链的 3 个字节，落在 ${chain.slots.join(", ")}`;
+		if (name === "body" && carried.join(",") === emptyBody.join(",")) detail = `${detail}；与空 body 一致，GET 就是这种情况`;
+		fields.push({
+			name: `${name}_digest`,
+			value: carried.join(" "),
+			kind: KIND.DIGEST,
+			detail
+		});
+		const candidate = inputByChain[name];
+		if (candidate === void 0) {
+			checks.push({
+				name,
+				status: CHECK.NOT_SUPPLIED,
+				bits: CHAIN_BITS
+			});
+			continue;
+		}
+		const digest = name === "user_agent" ? userAgentDigest(candidate, {
+			envFlags: raw.envFlags,
+			detectFlags: raw.detectFlags
+		}) : digestWith(candidate, SALT);
+		checks.push(check(name, chainBytes(chain, digest), carried, candidate));
+	}
+	return {
+		parameter: "a_bogus",
+		platform: "douyin",
+		algorithm: "a_bogus",
+		recovered: true,
+		fields,
+		checks,
+		notes: ["checksum_verified", "noise_not_recoverable"]
+	};
+};
+/**
+* 反推一份签名用的是哪个盐值 —— **这个工具存在的核心理由**。
+*
+* 做法与当初发现 `cus` 过期时完全一样：签名里封着 query 链的三个字节，把候选盐值逐个
+* 代进去重算摘要，能重现那三个字节的就是当前盐值。整件事不需要网络、不需要身份、
+* 也不依赖抖音是否接受了你的请求——这正是它能发现「请求照样成功但常量已经过期」的原因。
+*
+* ## 只有 query 链参与判定
+*
+* body 链在 GET 上与空串一致，而 UA 链**根本不吃盐值**（它走 RC4 加单次 SM3），
+* 两条对判定都没有贡献，所以这里的候选盐值只对 query 生效。证据量是 24 位，
+* 实战足够——但要说明，而不是藏起来。
+* @param value - 一份真实的 `a_bogus`
+* @param query - 该签名所覆盖的那条 query（不含 `a_bogus` 自身）
+* @param salts - 待测的盐值候选
+* @returns 判定结果
+*/
+const diagnoseSalt = (value, query, salts = [SALT, "cus"]) => {
+	if (structureError(value) !== null) return {
+		salt: null,
+		observed: [],
+		results: []
+	};
+	const chain = DIGEST_CHAINS.query;
+	const scalars = decode(value).fields;
+	const observed = chain.slots.map((slot) => scalars[slot]);
+	const results = salts.map((salt) => {
+		const predicted = chainBytes(chain, digestWith(query, salt));
+		return {
+			salt,
+			predicted,
+			matched: predicted.join(",") === observed.join(",")
+		};
+	});
+	return {
+		salt: results.find((row) => row.matched)?.salt ?? null,
+		observed,
+		results
+	};
+};
+/**
+* 只按形状猜一个值是什么参数。用于调用方不知道自己在看什么的时候。
+*
+* 只做形状判断，不做任何密码学断言——猜错时返回 `null` 比返回一个错答案好。
+* @param value - 待识别的值
+* @returns 参数名或 `null`
+*/
+const identify = (value) => {
+	if (!value) return null;
+	if (structureError(value) === null) return "a_bogus";
+	if (/^verify_[0-9a-z]+_/.test(value)) return "verifyFp";
+	if (value.length === 28 && /^[A-Za-z0-9_=+/-]+$/.test(value)) return "X-Bogus";
+	if (value.length >= 100 && /^[A-Za-z0-9+-]+=*$/.test(value)) return "msToken";
+	if (/^[0-9a-f]{32}$/i.test(value)) return "x-secsdk-web-signature";
+	return null;
+};
+/**
+* 签名**一定**不覆盖的参数。
+*
+* `a_bogus` 是签名自身；`timestamp` 与 `x-secsdk-web-signature` 由 secsdk 在签名
+* **之后**追加 —— 这一点在真实捕获与 amagi 自己的管线里一致。
+*/
+const NEVER_SIGNED = [
+	"a_bogus",
+	"timestamp",
+	"x-secsdk-web-signature"
+];
+/**
+* 是否被签名覆盖**随管线而异**的参数。
+*
+* 不要猜。真实浏览器捕获里 `uifid` 在 `a_bogus` **之前**（因而被签名覆盖），
+* 而 amagi 的管线是 `webid → a_bogus → secsdk`，`uifid` 由 secsdk 在之后补上
+* （因而没被覆盖）。同一个参数名，两边结论相反 —— 所以这里把四种参数做成
+* 2⁴ 种组合逐个试，命中的那一种就是答案。
+*/
+const SIGNING_AMBIGUOUS = [
+	"uifid",
+	"msToken",
+	"verifyFp",
+	"fp"
+];
+/**
+* 反推一份签名**当时覆盖的那条 query**，以及用的是哪个盐值。
+*
+* 这是 {@link diagnoseSalt} 的加强版：那份要求调用方已经知道签名覆盖了哪些参数，
+* 而线上抓来的 URL 里，`uifid` / `msToken` / `verifyFp` / `fp` 到底在签名前还是
+* 签名后，取决于页面当时挂的是哪条管线 —— 同一份代码在浏览器里和在 amagi 里顺序
+* 就是不一样的。与其让调用方去猜，这里把 2⁴ 种组合全试一遍，报出命中的那一种。
+*
+* 命中意味着**两件事同时成立**：这是一份结构良好的 a_bogus，且它的 query 链在给定
+* 盐值下重现了这条 query。所以它是「验证」而不只是「解码」。
+* @param signature - `a_bogus` 的值（未做 URL 编码）
+* @param url - 已签名的完整 URL
+* @param salts - 待搜的盐值候选
+* @returns 命中结果；没有任何组合命中时返回 `null`
+*/
+const recoverSignedQuery = (signature, url, salts = [SALT]) => {
+	if (structureError(signature) !== null) return null;
+	const chain = DIGEST_CHAINS.query;
+	const scalars = decode(signature).fields;
+	const observed = chain.slots.map((slot) => scalars[slot]).join(",");
+	let tried = 0;
+	for (let mask = 0; mask < 1 << SIGNING_AMBIGUOUS.length; mask++) {
+		const kept = SIGNING_AMBIGUOUS.filter((_, index) => (mask & 1 << index) !== 0);
+		const parsed = new URL(url);
+		for (const name of NEVER_SIGNED) parsed.searchParams.delete(name);
+		for (const name of SIGNING_AMBIGUOUS) if (!kept.includes(name)) parsed.searchParams.delete(name);
+		const query = parsed.searchParams.toString();
+		for (const salt of salts) {
+			tried++;
+			if (chainBytes(chain, digestWith(query, salt)).join(",") === observed) return {
+				query,
+				kept,
+				salt,
+				tried
+			};
+		}
+	}
+	return null;
+};
+/**
+* 从一条已签名的 URL 里重建出签名覆盖的那条 query（不再搜索，按固定规则摘参数）。
+*
+* **只在已知管线顺序时使用。** 面对来源不明的 URL 请用 {@link recoverSignedQuery}，
+* 它会搜索并告诉你哪条重建成立。保留这个函数是为了让「摘掉签名参数」这件事在
+* 需要确定行为的地方仍然可用。
+* @param url - 已签名的完整 URL
+* @returns 摘掉 `a_bogus` / `timestamp` / `x-secsdk-web-signature` 之后的 query
+*/
+const signedQueryOf = (url) => {
+	const parsed = new URL(url);
+	for (const name of NEVER_SIGNED) parsed.searchParams.delete(name);
+	return parsed.searchParams.toString();
+};
+/**
+* 拆开一条 URL 上所有认得出的签名参数。
+*
+* 会先尝试 {@link recoverSignedQuery} 找出签名真正覆盖的那条 query；找不到时退回
+* {@link signedQueryOf} 的结果，并把这个不确定性体现在 `notes` 里。
+* @param url - 已签名的完整 URL
+* @param options - 可选的 User-Agent、显式 query 与盐值候选
+* @returns 每个参数一条拆解结果
+*/
+const decodeUrl = (url, options = {}) => {
+	const aBogus = new URL(url).searchParams.get("a_bogus");
+	if (aBogus === null) return [];
+	const signature = decodeURIComponent(aBogus);
+	const recovery = options.query ? null : recoverSignedQuery(signature, url, options.salts ?? ["dhzx"]);
+	const query = options.query ?? recovery?.query ?? signedQueryOf(url);
+	const decoded = decodeABogus(signature, {
+		query,
+		body: options.body,
+		userAgent: options.userAgent
+	});
+	if (recovery) {
+		decoded.notes.push(`query_recovered:kept=${recovery.kept.join("+") || "(none)"}`);
+		decoded.fields.push({
+			name: "signed_query",
+			value: recovery.query,
+			kind: KIND.PLAIN,
+			detail: `从 ${recovery.tried} 种组合中命中：保留了 ${recovery.kept.join("、") || "（不保留任何可选参数）"}`
+		});
+	} else if (!options.query) decoded.notes.push("query_reconstructed_by_rule:no_combination_matched");
+	return [decoded];
+};
+//#endregion
+//#region src/platforms/douyin/sign/x_bogus.ts
+/**
+* X-Bogus 生成工具（抖音 / TikTok Web 的老签名）—— TypeScript 移植
+*
+* 移植自 Douyin_TikTok_Download_API `src/dtk/signing/native/xbogus.py`，常量、槽位与
+* **字节顺序**逐条对齐；那份 Python 又是 V4 `crawlers/douyin/web/xbogus.py` 的逐行移植，
+* 而 V4 是站点自己那份混淆 JS 的直译。所以这里对齐的不是「某份实现的做法」，
+* 而是站点校验时的做法。
+*
+* 整条依赖链只用 `TextEncoder` / `URL` 这类环境无关的原语（MD5 走 `utils/md5` 的纯
+* 实现），浏览器里能直接跑 —— `@ikenxuan/amagi/signing` 与文档站验证器用的就是这份。
+*
+* ## 载荷（19 字节）与槽位
+*
+* ```text
+* [64, 1/256, 1, 12, query 摘要[14..15], empty 摘要[14..15], ua 摘要[14..15],
+*  时间戳 4 字节, 536919696 4 字节, 校验位]
+* ```
+*
+* 三条摘要链各自算出 16 字节 MD5，只取第 14、15 字节（`DIGEST_INDICES`）；`1/256`
+* 是站点留在载荷里的浮点常量，最终被截断成 `0`；最后一格是前 18 格的异或。
+*
+* ## 两个曾经的坑，都会产出「看着像模像样」的错签名
+*
+* 1. **字节顺序**：站点把载荷按奇偶位拆开，再交给一个**形参表本身就乱序**的编码函数，
+*    而那个函数正好把两段拼回原序 —— 拆分是死代码。旧移植漏掉还原这一步，把
+*    「偶数位在前、奇数位在后」直接送进 RC4，字节全体错位；再叠加把 `1/256` 写成 `1`，
+*    输出与站点/V4 完全不同。见 {@link interleave}。
+* 2. **十六进制解码**：≤ 32 字符一律按站点的判据当摘要解十六进制，旧实现遇到落单的
+*    半字节会悄悄补 0（Python 那版是悄悄丢掉末位），两个不同输入能撞出同一签名。
+*    见 {@link md5StrToArray}。
+*
+* ## 时钟
+*
+* V4 把 `time.time()` 烧在函数体里，签名没法在测试里钉死。这里把秒级时间戳做成
+* 注入点（`options.timestamp`），默认值才是 `Date.now()`。
+*
+* ## 解码层
+*
+* 和 `a_bogus` 一样，X-Bogus 的载荷能整个拆开：信封头两个明文字节之后跟着 RC4 密文，
+* 密钥就是那个单字节 `PAYLOAD_KEY`，RC4 对称所以「解密」就是再加密一遍。拆开后
+* 时间戳是明文，三条摘要链各留两个字节可做候选输入校验——{@link decodeXBogus}。
+*
+* @module platforms/douyin/sign/x_bogus
+*/
+/** 输出字母表，与 a_bogus 的 `s2` 相同；两者可以各自演化，所以不共用一份 */
+const CHARACTER = "Dkdpgh4ZKsQB80/Mfvw36XI1R25-WUAlEi7NLboqYTOPuzmFjJnryx9HVGcaStCe=";
+/** 标准字母表的 base64（UA 摘要链用；V4 在这条链上用的是 `base64.b64encode`） */
+const STANDARD_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** 作用在 User-Agent 上的 RC4 密钥（三个控制字节） */
+const UA_KEY = [
+	0,
+	1,
+	12
+];
+/** 作用在载荷上的 RC4 密钥 */
+const PAYLOAD_KEY = [255];
+/** 站点混在时间戳旁边的固定常量 */
+const CANVAS_CONSTANT = 536919696;
+/** 空串的 MD5，算法会把它再哈希一轮，结果是个常量 */
+const EMPTY_MD5 = "d41d8cd98f00b204e9800998ecf8427e";
+/** 载荷开头四个槽位的字面量；`1/256` 那一格会被截断成 `0`，但不能顺手改写成 `0` */
+const PAYLOAD_LEAD = [
+	64,
+	1 / 256,
+	1,
+	12
+];
+/** 每条摘要链贡献的两个字节在 16 字节摘要里的下标 */
+const DIGEST_INDICES = [14, 15];
+/** 信封开头的两个明文字节（`2` 与 `255`），密文接在它们后面 */
+const ENVELOPE_LEAD = [2, 255];
+/** 一份 X-Bogus 的定长：7 组 × 4 字符 = 21 字节 = 信封 2 + 载荷 19 */
+const X_BOGUS_LENGTH = 28;
+/** 不传 UA 时使用的默认值，与 V4 一字不差（改它等于改签名） */
+const DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0";
+/** 小写十六进制字符，V4 与 xbogus.py 都只认这一档 */
+const HEX_DIGITS = "0123456789abcdef";
+/** 字符串按 latin1 取字节：每个码元截到 8 位，与 `Buffer.from(s, 'latin1')` 一致 */
+const latin1Bytes = (value) => {
+	const bytes = new Uint8Array(value.length);
+	for (let index = 0; index < value.length; index++) bytes[index] = value.charCodeAt(index) & 255;
+	return bytes;
+};
+/** 字节按 latin1 还原成字符串（信封与密文的搬运格式） */
+const bytesToLatin1 = (bytes) => {
+	let out = "";
+	for (let index = 0; index < bytes.length; index++) out += String.fromCharCode(bytes[index] & 255);
+	return out;
+};
+/** 标准字母表的 base64（带 `=` 填充），与 `Buffer#toString('base64')` 输出一致 */
+const encodeStandardBase64 = (bytes) => {
+	let out = "";
+	for (let offset = 0; offset < bytes.length; offset += 3) {
+		const chunk = [];
+		for (let i = 0; i < 3; i++) chunk.push(offset + i < bytes.length ? bytes[offset + i] : 0);
+		const block = chunk[0] << 16 | chunk[1] << 8 | chunk[2];
+		for (const digit of [
+			block >>> 18 & 63,
+			block >>> 12 & 63,
+			block >>> 6 & 63,
+			block & 63
+		]) out += STANDARD_BASE64[digit];
+	}
+	const pad = (3 - bytes.length % 3) % 3;
+	return out.slice(0, out.length - pad) + "=".repeat(pad);
+};
+/** RC4。对称流密码，解密与加密是同一个函数 */
+const rc4 = (key, data) => {
+	const box = Array.from({ length: 256 }, (_, index) => index);
+	let j = 0;
+	for (let index = 0; index < 256; index++) {
+		j = (j + box[index] + key[index % key.length]) % 256;
+		[box[index], box[j]] = [box[j], box[index]];
+	}
+	const out = new Uint8Array(data.length);
+	let i = 0;
+	j = 0;
+	for (let index = 0; index < data.length; index++) {
+		i = (i + 1) % 256;
+		j = (j + box[i]) % 256;
+		[box[i], box[j]] = [box[j], box[i]];
+		out[index] = data[index] ^ box[(box[i] + box[j]) % 256];
+	}
+	return out;
+};
+/**
+* 十六进制串 → 字节数组；超过 32 字符则按原始文本取码元（只取每码元的低位字节，
+* 与站点 `ord(c) & 0xff` 的语义一致）。
+*
+* **长度判据（≤ 32 走十六进制）是站点的**，不是这里加的：站点把任何不超过一份
+* 摘要长度的字符串都当作摘要来解。真实请求的 path + query 永远长过 32 字符，
+* 走的是文本分支，所以这条规则碰不到线上行为。
+*
+* **旧实现在这里会悄悄吞掉落单的半字节**，两个不同输入因此撞出同一份签名：
+* 参考实现（Python）用 `range(0, len - 1, 2)`，末位字符直接不参与运算，
+* `"abcdef"` 与 `"abcdefg"` 同签名；本仓库旧 TS 版把缺失的低半字节当成 0，
+* `"abc"` 与 `"abc0"` 同签名。两者的共同点是「输入不合法，却拿到一份像模像样的
+* 签名」—— 这比报错难查得多，所以这里选择**报错**：长度必须是偶数、字符必须是小写
+* 十六进制，否则抛出，绝不替调用方补位或丢位。
+*/
+const md5StrToArray = (value) => {
+	if (value.length > 32) {
+		const codePoints = [];
+		for (const char of value) codePoints.push(char.charCodeAt(0));
+		return codePoints;
+	}
+	const nibbles = new Map(HEX_DIGITS.split("").map((char, index) => [char, index]));
+	const bytes = [];
+	for (let index = 0; index < value.length; index += 2) {
+		const pair = value.slice(index, index + 2);
+		const high = nibbles.get(value[index]);
+		const low = index + 1 < value.length ? nibbles.get(value[index + 1]) : void 0;
+		if (high === void 0 || low === void 0) throw new Error(`X-Bogus 签名：${JSON.stringify(value)} 不是偶数长度的小写十六进制串（${JSON.stringify(pair)} 处）`);
+		bytes.push(high << 4 | low);
+	}
+	return bytes;
+};
+/** 字节摘要的十六进制 */
+const md5OfBytes = (bytes) => md5Hex(Uint8Array.from(bytes, (byte) => byte & 255));
+/** query 摘要链：两轮 MD5 */
+const queryDigestOf = (urlPath) => md5StrToArray(md5OfBytes(md5StrToArray(md5OfBytes(md5StrToArray(urlPath)))));
+/** empty 摘要链：哈希空串，是个常量。第 14、15 字节出现在每一份 X-Bogus 里 */
+const emptyDigestOf = () => md5StrToArray(md5OfBytes(md5StrToArray(EMPTY_MD5)));
+/** UA 摘要链：RC4 → 标准 base64 → MD5。base64 是纯 ASCII，直接按文本进 MD5（等价 latin1 字节） */
+const uaDigestOf = (userAgent) => md5StrToArray(md5Hex(encodeStandardBase64(rc4(UA_KEY, latin1Bytes(userAgent)))));
+/**
+* 偶数位在前、奇数位在后 —— 站点对载荷做的拆分。
+*
+* 拆分本身是死代码（{@link interleave} 会把它原样拼回去），真正的作用只有
+* 一处：让 `1/256` 那一格被截断成整数。形状照抄站点，为的是别人对着 xbogus.py 读时
+* 能一句一句对上，也让「漏掉还原」这个坑不至于再犯一次。
+*/
+const splitEvenOdd = (values) => {
+	const head = [];
+	const tail = [];
+	for (let index = 0; index < values.length; index++) if (index % 2 === 0) head.push(values[index]);
+	else tail.push(values[index]);
+	return [...head, ...tail];
+};
+/** 把 {@link splitEvenOdd} 拆开的两段按下标交错回原序（顺便截断成整数）。 */
+const interleave = (values) => {
+	const head = values.slice(0, 10);
+	const tail = values.slice(10);
+	const merged = [];
+	for (let index = 0; index < head.length; index++) {
+		merged.push(Math.trunc(head[index]));
+		if (index < tail.length) merged.push(Math.trunc(tail[index]));
+	}
+	return merged;
+};
+/** 三个载荷字节 → 四个输出字符 */
+const encodeGroup = (first, second, third) => {
+	const merged = (first & 255) << 16 | (second & 255) << 8 | third & 255;
+	return CHARACTER[(merged & 16515072) >> 18] + CHARACTER[(merged & 258048) >> 12] + CHARACTER[(merged & 4032) >> 6] + CHARACTER[merged & 63];
+};
+var XBogus = class {
+	/** V4 兼容字段：V4 会把结果同步写进 `params` / `xb`，本实现不写 */
+	params;
+	xb;
+	/**
+	* 生成 X-Bogus 签名。
+	*
+	* @param url - 完整的 URL 地址（签的是它的 pathname + search）
+	* @param ua - 可选的 User-Agent，不提供则使用默认值
+	* @param options - `timestamp` 注入点（秒级），省略时取当前时间
+	* @returns 完整 URL（已带 `X-Bogus=`）、签名值与实际使用的 User-Agent
+	*/
+	getXBogus(url, ua, options = {}) {
+		const parsedUrl = new URL(url);
+		const urlPath = parsedUrl.pathname + parsedUrl.search;
+		const userAgent = ua ?? DEFAULT_USER_AGENT;
+		const timestamp = options.timestamp ?? Math.floor(Date.now() / 1e3);
+		const xbogus = signXBogus(urlPath, userAgent, timestamp);
+		return {
+			fullUrl: url.includes("?") ? `${url}&X-Bogus=${xbogus}` : `${url}?X-Bogus=${xbogus}`,
+			xbogus,
+			userAgent
+		};
+	}
+};
+/**
+* 对一条 path+search 签出 X-Bogus。
+*
+* {@link XBogus.getXBogus} 的函数式形态 —— 验证工具要用它对候选输入重签；
+* 输入是已经拆好的 `pathname + search`，不重复解析 URL。
+* @param urlPath - 参与 签名的 `pathname + search`
+* @param userAgent - 参与签名的 User-Agent
+* @param timestamp - 秒级时间戳
+* @returns 28 个字符的签名值
+*/
+const signXBogus = (urlPath, userAgent, timestamp) => {
+	const queryDigest = queryDigestOf(urlPath);
+	const emptyDigest = emptyDigestOf();
+	const uaDigest = uaDigestOf(userAgent);
+	const payload = [
+		...PAYLOAD_LEAD,
+		queryDigest[DIGEST_INDICES[0]],
+		queryDigest[DIGEST_INDICES[1]],
+		emptyDigest[DIGEST_INDICES[0]],
+		emptyDigest[DIGEST_INDICES[1]],
+		uaDigest[DIGEST_INDICES[0]],
+		uaDigest[DIGEST_INDICES[1]],
+		timestamp >> 24 & 255,
+		timestamp >> 16 & 255,
+		timestamp >> 8 & 255,
+		timestamp & 255,
+		32,
+		0,
+		190,
+		144
+	];
+	let checksum = Math.trunc(payload[0]);
+	for (let index = 1; index < payload.length; index++) checksum ^= Math.trunc(payload[index]);
+	payload.push(checksum);
+	const encrypted = rc4(PAYLOAD_KEY, Uint8Array.from(interleave(splitEvenOdd(payload))));
+	const garbled = `${String.fromCharCode(ENVELOPE_LEAD[0], ENVELOPE_LEAD[1])}${bytesToLatin1(encrypted)}`;
+	let xbogus = "";
+	for (let index = 0; index + 2 < garbled.length; index += 3) xbogus += encodeGroup(garbled.charCodeAt(index), garbled.charCodeAt(index + 1), garbled.charCodeAt(index + 2));
+	return xbogus;
+};
+/**
+* 只凭签名本身能做的全部检查 —— 不需要任何候选输入。
+*
+* X-Bogus 里封着三个**常量**（载荷前四格、empty 摘要链字节、canvas 常量），
+* 它们与校验位一起构成指纹：一份能通过全部检查的值，必然出自这套算法的装配顺序。
+* @param value - 待检查的值（28 个字符）
+* @returns 第一个发现的问题；`null` 表示全部通过
+*/
+const xBogusStructureError = (value) => {
+	if (value.length !== X_BOGUS_LENGTH) return "length not 28";
+	const table = new Map(CHARACTER.split("").map((char, index) => [char, index]));
+	const bytes = [];
+	for (let offset = 0; offset < value.length; offset += 4) {
+		let block = 0;
+		for (const char of value.slice(offset, offset + 4)) {
+			const digit = table.get(char);
+			if (digit === void 0) return "alphabet";
+			block = block << 6 | digit;
+		}
+		bytes.push(block >>> 16 & 255, block >>> 8 & 255, block & 255);
+	}
+	if (bytes[0] !== ENVELOPE_LEAD[0] || bytes[1] !== ENVELOPE_LEAD[1]) return "envelope lead";
+	const payload = Array.from(rc4(PAYLOAD_KEY, Uint8Array.from(bytes.slice(2))));
+	const canvasBytes = [
+		32,
+		0,
+		190,
+		144
+	];
+	const emptyBytes = emptyDigestOf();
+	if (payload.slice(0, 4).join(",") !== [
+		64,
+		0,
+		1,
+		12
+	].join(",")) return "lead slots";
+	if (payload[6] !== emptyBytes[DIGEST_INDICES[0]] || payload[7] !== emptyBytes[DIGEST_INDICES[1]]) return "empty digest";
+	if (payload.slice(14, 18).join(",") !== canvasBytes.join(",")) return "canvas constant";
+	let checksum = payload[0];
+	for (let index = 1; index < 18; index++) checksum ^= payload[index];
+	return checksum === payload[18] ? null : "checksum";
+};
+/**
+* 拆开一份 X-Bogus，并就调用方给出的候选值做校验。
+*
+* 能原样读回的只有一个值：秒级时间戳。三条摘要链各留两个字节（16 位），输入无法
+* 从中倒推，做的是校验 —— 给候选值，回答是不是它封的那一个。证据量比 a_bogus
+* 的 24 位小，但足以区分「对着的 URL」与「差一个参数的 URL」。
+* @param value - X-Bogus 的值（28 个字符）
+* @param candidates - 候选的 path+search 与 User-Agent，给哪个校验哪个
+* @returns 拆解结果；格式不合法时 `recovered` 为 `false` 并给出 `reason`
+*/
+const decodeXBogus = (value, candidates = {}) => {
+	const problem = xBogusStructureError(value);
+	if (problem !== null) return {
+		parameter: "X-Bogus",
+		platform: "douyin",
+		algorithm: "X-Bogus",
+		recovered: false,
+		reason: `${REASON.MALFORMED}:${problem}`,
+		fields: [],
+		checks: [],
+		notes: []
+	};
+	const table = new Map(CHARACTER.split("").map((char, index) => [char, index]));
+	const bytes = [];
+	for (let offset = 0; offset < value.length; offset += 4) {
+		let block = 0;
+		for (const char of value.slice(offset, offset + 4)) block = block << 6 | table.get(char);
+		bytes.push(block >>> 16 & 255, block >>> 8 & 255, block & 255);
+	}
+	const payload = Array.from(rc4(PAYLOAD_KEY, Uint8Array.from(bytes.slice(2))));
+	const timestamp = (payload[10] << 24 | payload[11] << 16 | payload[12] << 8 | payload[13]) >>> 0;
+	const carried = {
+		query: [payload[4], payload[5]],
+		empty: [payload[6], payload[7]],
+		user_agent: [payload[8], payload[9]]
+	};
+	const fields = [
+		{
+			name: "header_lead",
+			value: "[2, 255]",
+			kind: KIND.PLAIN
+		},
+		{
+			name: "lead_slots",
+			value: "[64, 0, 1, 12]",
+			kind: KIND.PLAIN,
+			detail: "第三格在载荷里写的是 1/256，编码前被截断成 0"
+		},
+		clockField("timestamp", timestamp * 1e3, "秒级时钟，与 a_bogus 的毫秒时钟不同源"),
+		{
+			name: "canvas_constant",
+			value: String(CANVAS_CONSTANT),
+			kind: KIND.PLAIN
+		},
+		...[
+			"query",
+			"empty",
+			"user_agent"
+		].map((name) => ({
+			name: `${name}_digest`,
+			value: carried[name].join(" "),
+			kind: KIND.DIGEST,
+			detail: `${name} 链的 2 个字节（MD5 摘要的第 14、15 格）`
+		})),
+		{
+			name: "checksum",
+			value: String(payload[18]),
+			kind: KIND.CHECKSUM,
+			detail: "前 18 格逐格异或"
+		}
+	];
+	const candidateOf = {
+		query: candidates.query,
+		empty: "",
+		user_agent: candidates.userAgent
+	};
+	const predict = (name) => {
+		const digest = name === "query" ? queryDigestOf(candidates.query) : uaDigestOf(candidates.userAgent);
+		return [digest[DIGEST_INDICES[0]], digest[DIGEST_INDICES[1]]];
+	};
+	return {
+		parameter: "X-Bogus",
+		platform: "douyin",
+		algorithm: "X-Bogus",
+		recovered: true,
+		fields,
+		checks: [
+			"query",
+			"empty",
+			"user_agent"
+		].map((name) => {
+			const observed = carried[name];
+			if (name === "empty") {
+				const expected = emptyDigestOf();
+				return {
+					name,
+					status: expected[DIGEST_INDICES[0]] === observed[0] && expected[DIGEST_INDICES[1]] === observed[1] ? CHECK.MATCH : CHECK.DIFFERS,
+					bits: 16
+				};
+			}
+			const candidate = candidateOf[name];
+			if (candidate === void 0) return {
+				name,
+				status: CHECK.NOT_SUPPLIED,
+				bits: 16
+			};
+			return predict(name).join(",") === observed.join(",") ? {
+				name,
+				status: CHECK.MATCH,
+				bits: 16,
+				covered: candidate
+			} : {
+				name,
+				status: CHECK.DIFFERS,
+				bits: 16
+			};
+		}),
+		notes: ["checksum_verified", "structure_constants_verified"]
+	};
+};
+//#endregion
+//#region src/platforms/kuaishou/sign/hudr.ts
+const KUAISHOU_HUDR_PREFIX = "HUDR_";
+const KUAISHOU_HUDR_MASK_BYTE = 35;
+const KUAISHOU_HUDR_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const KUAISHOU_HUDR_CHACHA_KEY = [
+	4183807412,
+	394484062,
+	1106561997,
+	2378328696,
+	630790222,
+	2546784104,
+	2891127470,
+	1922531795
+];
+const KUAISHOU_HUDR_CHACHA_NONCE = [
+	2215853858,
+	1643070585,
+	1849059804
+];
+/** 将字符串转换为 Unicode code point 数组。 */
+const toCodePointArray = (value) => {
+	return Array.from(value).map((char) => char.codePointAt(0) ?? 0);
+};
+/** 以小端序输出固定长度字节数组。 */
+const toLittleEndianBytes = (value, size = 4) => {
+	if (size >= 4 && value >= Math.pow(2, 32)) return [
+		255,
+		255,
+		255,
+		255
+	];
+	const result = [];
+	for (let index = 0; index <= size - 1; index++) result[index] = value >>> 8 * index & 255;
+	return result;
+};
+/** 对字节切片执行标准 Base64 编码。 */
+const encodeBase64Slice = (bytes, start, end) => {
+	const result = [];
+	for (let index = start; index < end; index += 3) {
+		const value = (bytes[index] << 16 & 16711680) + (bytes[index + 1] << 8 & 65280) + (bytes[index + 2] & 255);
+		result.push(KUAISHOU_HUDR_BASE64_ALPHABET[value >> 18 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value >> 12 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value >> 6 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value & 63]);
+	}
+	return result.join("");
+};
+/** 快手 `HUDR_` 使用的 Base64URL 变体编码。 */
+const encodeBase64Url = (bytes) => {
+	const result = [];
+	const remainder = bytes.length % 3;
+	const tripletLength = bytes.length - remainder;
+	for (let index = 0; index < tripletLength; index += 16383) {
+		const end = tripletLength < index + 16383 ? tripletLength : index + 16383;
+		result.push(encodeBase64Slice(bytes, index, end));
+	}
+	if (remainder === 1) {
+		const value = bytes[bytes.length - 1];
+		result.push(KUAISHOU_HUDR_BASE64_ALPHABET[value >> 2], KUAISHOU_HUDR_BASE64_ALPHABET[value << 4 & 63], "==");
+	} else if (remainder === 2) {
+		const value = (bytes[bytes.length - 2] << 8) + bytes[bytes.length - 1];
+		result.push(KUAISHOU_HUDR_BASE64_ALPHABET[value >> 10], KUAISHOU_HUDR_BASE64_ALPHABET[value >> 4 & 63], KUAISHOU_HUDR_BASE64_ALPHABET[value << 2 & 63], "=");
+	}
+	return result.join("").replace(/[+/=]/g, (char) => {
+		if (char === "+") return "-";
+		if (char === "/") return "_";
+		return ".";
+	});
+};
+/**
+* 快手 `HUDR_` 所用的 ChaCha20 变体实现。
+*
+* 该实现并非通用密码库封装，而是为对齐页面 `$encode`
+* 数据流而最小化保留的局部算法。
+*/
+var KuaishouChaChaCipher = class {
+	key;
+	nonce;
+	wordIndex = 0;
+	state = new Array(16).fill(0);
+	constructor(key, nonce) {
+		this.key = key;
+		this.nonce = nonce;
+	}
+	rotateLeft(value, shift) {
+		return (value << shift | value >>> 32 - shift) >>> 0;
+	}
+	quarterRound(target, a, b, c, d) {
+		target[a] = target[a] + target[b] >>> 0;
+		target[d] ^= target[a];
+		target[d] = this.rotateLeft(target[d], 16);
+		target[c] = target[c] + target[d] >>> 0;
+		target[b] ^= target[c];
+		target[b] = this.rotateLeft(target[b], 12);
+		target[a] = target[a] + target[b] >>> 0;
+		target[d] ^= target[a];
+		target[d] = this.rotateLeft(target[d], 8);
+		target[c] = target[c] + target[d] >>> 0;
+		target[b] ^= target[c];
+		target[b] = this.rotateLeft(target[b], 7);
+	}
+	refillBlock() {
+		const working = this.state.slice();
+		for (let round = 0; round < 20; round += 2) {
+			this.quarterRound(working, 0, 4, 8, 12);
+			this.quarterRound(working, 1, 5, 9, 13);
+			this.quarterRound(working, 2, 6, 10, 14);
+			this.quarterRound(working, 3, 7, 11, 15);
+			this.quarterRound(working, 0, 5, 10, 15);
+			this.quarterRound(working, 1, 6, 11, 12);
+			this.quarterRound(working, 2, 7, 8, 13);
+			this.quarterRound(working, 3, 4, 9, 14);
+		}
+		const mixedState = new Array(16).fill(0);
+		for (let index = 0; index < 16; index++) mixedState[index] = working[index] + this.state[index] >>> 0;
+		return mixedState;
+	}
+	encrypt(input) {
+		this.wordIndex = 0;
+		this.state[0] = 394484062;
+		this.state[1] = 2378328696;
+		this.state[2] = 630790222;
+		this.state[3] = 1922531795;
+		for (let index = 0; index < 8; index++) this.state[index + 4] = this.key[index] >>> 0;
+		this.state[12] = 1;
+		this.state[13] = this.nonce[0] >>> 0;
+		this.state[14] = this.nonce[1] >>> 0;
+		this.state[15] = this.nonce[2] >>> 0;
+		let mixedState = this.refillBlock();
+		const output = new Uint8Array(input.length);
+		for (let index = 0; index < input.length; index++) {
+			if (this.wordIndex === 64) {
+				this.state[12] = this.state[12] + 1 >>> 0;
+				mixedState = this.refillBlock();
+				this.wordIndex = 0;
+			}
+			const keystreamByte = mixedState[this.wordIndex >> 2] >>> ((this.wordIndex & 3) << 3) & 255;
+			this.wordIndex += 1;
+			output[index] = input[index] ^ keystreamByte;
+		}
+		return output;
+	}
+};
+/**
+* 构造 `HUDR_` 头部中的 `infoCache` 字段。
+*
+* @param scriptCount - 页面脚本数量
+* @returns `HUDR_` 载荷中的脚本信息缓存字节
+*/
+const buildKuaishouHudrInfoCache = (scriptCount = 0) => {
+	return [68, 0].concat(toLittleEndianBytes(scriptCount, 4));
+};
+/**
+* 构造快手 `HUDR_` 原始载荷。
+*
+* @param context - 生成 `HUDR_` 所需的上下文参数
+* @returns 尚未异或和加密的原始字节载荷
+*/
+const buildKuaishouHudrPayload = (context) => {
+	const stackTail = context.secs?.s ?? "";
+	const secsCount = context.secs?.c ?? 0;
+	const count = context.count || 0;
+	return [
+		45,
+		61,
+		0,
+		2
+	].concat(buildKuaishouHudrInfoCache(context.scriptCount)).concat([112, 0], toLittleEndianBytes(count, 4)).concat([114, 1], toLittleEndianBytes(stackTail.length, 2), toCodePointArray(stackTail)).concat([115, 0], toLittleEndianBytes(secsCount, 4));
+};
+/**
+* 对 `HUDR_` 原始载荷执行页面同款掩码异或。
+*
+* @param payload - 原始 `HUDR_` 字节载荷
+* @returns 掩码处理后的字节数组
+*/
+const maskKuaishouHudrPayload = (payload) => {
+	const masked = new Uint8Array(payload.length);
+	for (let index = 0; index < payload.length; index++) masked[index] = KUAISHOU_HUDR_MASK_BYTE ^ payload[index];
+	return masked;
+};
+/**
+* 推导快手签名中的 `HUDR_` 段。
+*
+* @param context - 生成 `HUDR_` 所需的上下文参数
+* @returns `HUDR_` 的完整结果及若干中间态，便于对拍与调试
+*/
+const deriveKuaishouHudrBody = (context) => {
+	const payload = buildKuaishouHudrPayload(context);
+	const maskedPayload = maskKuaishouHudrPayload(payload);
+	const encrypted = new KuaishouChaChaCipher(KUAISHOU_HUDR_CHACHA_KEY, KUAISHOU_HUDR_CHACHA_NONCE).encrypt(maskedPayload);
+	const body = encodeBase64Url(encrypted);
+	return {
+		body,
+		full: `${KUAISHOU_HUDR_PREFIX}${body}`,
+		infoCache: buildKuaishouHudrInfoCache(context.scriptCount),
+		maskedPayload,
+		nextCount: context.count + 1
+	};
+};
+//#endregion
+//#region src/platforms/kuaishou/sign/primitives.ts
+const KUAISHOU_BLAKE2S_IV = [
+	2837534710,
+	2845986804,
+	2436420605,
+	706843635,
+	719254516,
+	2557931286,
+	2596197199,
+	2432949778
+];
+const KUAISHOU_BLAKE2S_SIGMA = [
+	[
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15
+	],
+	[
+		14,
+		10,
+		4,
+		8,
+		9,
+		15,
+		13,
+		6,
+		1,
+		12,
+		0,
+		2,
+		11,
+		7,
+		5,
+		3
+	],
+	[
+		11,
+		8,
+		12,
+		0,
+		5,
+		2,
+		15,
+		13,
+		10,
+		14,
+		3,
+		6,
+		7,
+		1,
+		9,
+		4
+	],
+	[
+		7,
+		9,
+		3,
+		1,
+		13,
+		12,
+		11,
+		14,
+		2,
+		6,
+		5,
+		10,
+		4,
+		0,
+		15,
+		8
+	],
+	[
+		9,
+		0,
+		5,
+		7,
+		2,
+		4,
+		10,
+		15,
+		14,
+		1,
+		11,
+		12,
+		6,
+		8,
+		3,
+		13
+	],
+	[
+		2,
+		12,
+		6,
+		10,
+		0,
+		11,
+		8,
+		3,
+		4,
+		13,
+		7,
+		5,
+		15,
+		14,
+		1,
+		9
+	],
+	[
+		12,
+		5,
+		1,
+		15,
+		14,
+		13,
+		4,
+		10,
+		0,
+		7,
+		6,
+		3,
+		9,
+		2,
+		8,
+		11
+	],
+	[
+		13,
+		11,
+		7,
+		14,
+		12,
+		1,
+		3,
+		9,
+		5,
+		0,
+		15,
+		4,
+		8,
+		6,
+		2,
+		10
+	],
+	[
+		6,
+		15,
+		14,
+		9,
+		11,
+		3,
+		0,
+		8,
+		12,
+		2,
+		13,
+		7,
+		1,
+		4,
+		10,
+		5
+	],
+	[
+		10,
+		2,
+		8,
+		4,
+		7,
+		6,
+		1,
+		5,
+		15,
+		11,
+		9,
+		14,
+		3,
+		12,
+		13,
+		0
+	]
+];
+const KUAISHOU_CTS_STATE_VECTOR = new Int8Array([
+	98,
+	0,
+	0,
+	128,
+	49,
+	117,
+	185,
+	253,
+	224,
+	172,
+	104,
+	36,
+	223,
+	155,
+	87,
+	19,
+	32,
+	0,
+	0,
+	64,
+	2,
+	0,
+	0,
+	16,
+	255,
+	255,
+	255,
+	127,
+	255,
+	255,
+	255,
+	63,
+	0,
+	0,
+	0,
+	240,
+	0,
+	0,
+	0,
+	192,
+	0,
+	0,
+	0,
+	128,
+	255,
+	255,
+	255,
+	15
+]);
+const rotateRight = (value, shift) => {
+	return (value >>> shift | value << 32 - shift) >>> 0;
+};
+const toUtf8Int8Array = (value) => {
+	return new Int8Array(unescape(encodeURIComponent(value)).split("").map((char) => char.charCodeAt(0) || 0));
+};
+const toHex32 = (value) => {
+	return (value >>> 0).toString(16).padStart(8, "0");
+};
+const blake2sQuarterRound = (state, a, b, c, d, x, y) => {
+	state[a] = state[a] + state[b] + x >>> 0;
+	state[d] = rotateRight(state[d] ^ state[a], 16);
+	state[c] = state[c] + state[d] >>> 0;
+	state[b] = rotateRight(state[b] ^ state[c], 12);
+	state[a] = state[a] + state[b] + y >>> 0;
+	state[d] = rotateRight(state[d] ^ state[a], 8);
+	state[c] = state[c] + state[d] >>> 0;
+	state[b] = rotateRight(state[b] ^ state[c], 7);
+};
+const blake2sCompress = (hash, words, offset, counter, length, isLastBlock) => {
+	const work = new Array(16).fill(0);
+	const block = new Array(16).fill(0);
+	for (let index = 0; index < 8; index++) {
+		work[index] = hash[index] >>> 0;
+		work[index + 8] = KUAISHOU_BLAKE2S_IV[index] >>> 0;
+	}
+	work[12] ^= counter >>> 0;
+	if (isLastBlock) work[14] ^= 4294967295;
+	for (let index = 0; index < length; index++) block[index % 16] ^= words[offset + index] >>> 0;
+	for (const sigma of KUAISHOU_BLAKE2S_SIGMA) {
+		blake2sQuarterRound(work, 0, 4, 8, 12, block[sigma[0]], block[sigma[1]]);
+		blake2sQuarterRound(work, 1, 5, 9, 13, block[sigma[2]], block[sigma[3]]);
+		blake2sQuarterRound(work, 2, 6, 10, 14, block[sigma[4]], block[sigma[5]]);
+		blake2sQuarterRound(work, 3, 7, 11, 15, block[sigma[6]], block[sigma[7]]);
+		blake2sQuarterRound(work, 0, 5, 10, 15, block[sigma[8]], block[sigma[9]]);
+		blake2sQuarterRound(work, 1, 6, 11, 12, block[sigma[10]], block[sigma[11]]);
+		blake2sQuarterRound(work, 2, 7, 8, 13, block[sigma[12]], block[sigma[13]]);
+		blake2sQuarterRound(work, 3, 4, 9, 14, block[sigma[14]], block[sigma[15]]);
+	}
+	for (let index = 0; index < 8; index++) hash[index] = (hash[index] ^ work[index] ^ work[index + 8]) >>> 0;
+	return hash;
+};
+const deriveB2hasWords = (value) => {
+	const utf8 = toUtf8Int8Array(value);
+	const padding = utf8.length % 4 === 0 ? 0 : 4 - utf8.length % 4;
+	const padded = new Int8Array(utf8.length + padding);
+	for (let index = 0; index < utf8.length; index++) padded[index] = utf8[index];
+	const words = new Array(padded.length / 4);
+	for (let index = 0; index < padded.length; index += 4) words[index / 4] = new Int32Array(padded.slice(index, index + 4).buffer)[0];
+	return words;
+};
+const deriveB2hasHash = (words) => {
+	const hash = KUAISHOU_BLAKE2S_IV.slice();
+	hash[0] ^= 16842784;
+	let offset = 0;
+	let length = words.length;
+	let counter = 0;
+	while (length > 64) {
+		length -= 64;
+		counter += 64;
+		blake2sCompress(hash, words, offset, counter, 64, false);
+		offset += 64;
+	}
+	return blake2sCompress(hash, words, offset, counter + length, length, true);
+};
+/**
+* 计算快手页面中的 `b2has` 字符串。
+*
+* 这是后续 `b2sa` / `cts` 链路的起点。
+*
+* @param value - 原始输入字符串
+* @returns `b2has` 结果字符串
+*/
+const deriveKuaishouB2has = (value) => {
+	return deriveB2hasHash(deriveB2hasWords(value)).map(toHex32).join("");
+};
+/**
+* 将输入字符串转换为快手 `b2sa` 所需的字节数组。
+*
+* @param value - 原始输入字符串
+* @returns `b2has` 结果转 UTF-8 后的 Int8Array
+*/
+const deriveKuaishouB2sa = (value) => {
+	return toUtf8Int8Array(deriveKuaishouB2has(value));
+};
+const createKuaishouCtsState = () => {
+	return {
+		s: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(12, 16).buffer)[0],
+		u: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(8, 12).buffer)[0],
+		c: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(4, 8).buffer)[0],
+		l: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(0, 4).buffer)[0],
+		p: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(16, 20).buffer)[0],
+		f: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(20, 24).buffer)[0],
+		d: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(24, 28).buffer)[0],
+		y: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(28, 32).buffer)[0],
+		h: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(44, 48).buffer)[0],
+		E: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(40, 44).buffer)[0],
+		m: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(36, 40).buffer)[0],
+		b: new Int32Array(KUAISHOU_CTS_STATE_VECTOR.slice(32, 36).buffer)[0]
+	};
+};
+const seedKuaishouCtsState = (state, seed) => {
+	const chars = new Int8Array(seed.split("").map((char) => char.codePointAt(0) ?? 0)).slice(0, seed.length);
+	for (let index = 0; index < 4; index++) {
+		state.s = (state.s <<= 8) | chars[index + 4];
+		state.u = (state.u <<= 8) | chars[index + 4];
+		state.c = (state.c <<= 8) | chars[index + 4];
+	}
+	if (state.s === 0) state.s = 324508639;
+	if (state.u === 0) state.u = 610839776;
+	if (state.c === 0) state.c = 4256789809;
+};
+const deriveKuaishouCtsByte = (state, value) => {
+	let result = 0;
+	let rightBit = 1 & state.u;
+	let leftBit = 1 & state.c;
+	for (let index = 0; index < 8; index++) {
+		if (1 & state.s) {
+			state.s = state.s ^ state.l >> 1 & 4294967295 | state.E;
+			rightBit = 1 & state.u ? (state.u = state.u ^ state.p >> 1 & 4294967295 | state.m, 1) : (state.u = state.u >> 1 & 4294967295 & state.y, 0);
+		} else {
+			state.s = state.s >> 1 & 4294967295 & state.d;
+			leftBit = 1 & state.c ? (state.c = state.c ^ state.f >> 1 & 4294967295 | state.b, 1) : (state.c = state.c >> 1 & 4294967295 & state.h, 0);
+		}
+		const mixed = result << 1 & 4294967295 | rightBit ^ leftBit;
+		result = mixed > 127 ? mixed - 256 : mixed < -128 ? mixed + 256 : mixed;
+	}
+	return value ^ result + 3;
+};
+/**
+* 执行快手页面中的 `cts` 字节流变换。
+*
+* 该变换会作用在 `b2sa` 的输出上，随后被 `$HE_` 使用。
+*
+* @param input - 输入字节数组
+* @returns 变换后的字节数组
+*/
+const deriveKuaishouCts = (input) => {
+	const state = createKuaishouCtsState();
+	seedKuaishouCtsState(state, "Vuz4fCHxn1CO");
+	const result = new Int8Array(input.length);
+	for (let index = 0; index < input.length; index++) result[index] = deriveKuaishouCtsByte(state, input[index]);
+	return result;
+};
+/**
+* 将字节数组编码为小写 hex 字符串。
+*
+* @param bytes - 任意可按字节访问的数组
+* @returns 小写 hex 字符串
+*/
+const bytesToLowerHex = (bytes) => {
+	let result = "";
+	for (const byte of Array.from(bytes)) {
+		const value = byte & 255;
+		result += value === 0 ? "00" : `${value < 16 ? "0" : ""}${value.toString(16)}`;
+	}
+	return result;
+};
+/**
+* 将 hex 字符串还原为带符号字节数组。
+*
+* @param value - 偶数字节长度的 hex 字符串
+* @returns 带符号 byte 数组
+*/
+const hexToSignedBytes = (value) => {
+	const result = [];
+	for (let index = 0; index < value.length; index += 2) {
+		const parsed = parseInt(value.slice(index, index + 2), 16);
+		const range = Math.pow(2, value.slice(index, index + 2).length / 2 * 8);
+		result.push(parsed > range / 2 - 1 ? parsed - range : parsed);
+	}
+	return result;
+};
+/**
+* 对两个字节数组执行循环异或。
+*
+* @param left - 被处理的字节数组
+* @param right - 异或掩码字节数组
+* @returns 异或后的 Int8Array
+*/
+const xorByteArrays = (left, right) => {
+	let index = 0;
+	const result = new Int8Array(left.length);
+	while (index < left.length) for (let rightIndex = 0; rightIndex < right.length && index < left.length; rightIndex++) {
+		result[index] = left[index] ^ 255 & right[rightIndex];
+		index += 1;
+	}
+	return result;
+};
+/**
+* 将数值编码为固定长度的小端 hex。
+*
+* @param value - 原始数值
+* @param size - 输出字节长度
+* @returns 小端序 hex 字符串
+*/
+const toLittleEndianHex = (value, size) => {
+	const normalized = BigInt.asUintN(size * 8, typeof value === "bigint" ? value : BigInt(Math.trunc(value)));
+	let result = "";
+	for (let index = 0; index < size; index++) {
+		const byte = Number(normalized >> BigInt(8 * index) & 255n);
+		result += byte.toString(16).padStart(2, "0");
+	}
+	return result;
+};
+/**
+* 计算快手 `$HE_` 所使用的 8-bit LRC 校验值。
+*
+* @param sourceHex - 原始 hex 字符串
+* @returns 单字节 LRC 的 hex 表示
+*/
+const computeKuaishouLrcHex = (sourceHex) => {
+	return (-hexToSignedBytes(sourceHex).reduce((total, value) => total + (value & 255), 0) & 255).toString(16).padStart(2, "0");
+};
+/**
+* 对 `$HE_` 的 preHex + checksum 执行最终变换。
+*
+* 页面实现会以最后一个字节为 key，对前面的字节逐个异或，
+* 最后再整体转回小写 hex。
+*
+* @param prefixHex - 不含最终 LRC 的前缀 hex
+* @param checksumHex - 最终 LRC hex
+* @returns `$HE_` 最终输出的 hex 字符串
+*/
+const transformKuaishouHeHex = (prefixHex, checksumHex) => {
+	const input = hexToSignedBytes(`${prefixHex}${checksumHex}`);
+	const output = new Int8Array(input.length);
+	const xorKey = input[input.length - 1];
+	for (let index = 0; index < input.length - 1; index++) output[index] = input[index] ^ xorKey;
+	output[input.length - 1] = xorKey;
+	return bytesToLowerHex(output);
+};
+//#endregion
+//#region src/platforms/kuaishou/sign/he.ts
+const KUAISHOU_HE_HEADER_HEX = "4B54";
+const KUAISHOU_HE_VERSION_HEX = "cda9";
+const KUAISHOU_HE_STARTUP_MARKER_HEX = "ab";
+const KUAISHOU_HE_FIXED_BODY_HEX = "0100000001";
+const KUAISHOU_HE_INPUT_XOR_MASK = [
+	45,
+	211,
+	69,
+	192
+];
+const KUAISHOU_HE_COUNTER_XOR_MASK = 3131873467;
+const KUAISHOU_HE_TIME_XOR_MASK = 3360347992n;
+const KUAISHOU_HE_TAIL_HEX = "9b563eda7b563e";
+const KUAISHOU_HE_RANDOM_MAX = 0xffffffffffff;
+/**
+* 计算 `$HE_` 中的 hash field。
+*
+* 它由 `signInput + HUDRBody` 经 `b2sa -> cts -> 截断 -> 异或掩码`
+* 这条链路导出，是 `$HE_` 中与接口输入最直接相关的一段。
+*
+* @param signInput - 快手 `__NS_hxfalcon` 的 sign input
+* @param hudrBody - `HUDR_` 去前缀后的主体
+* @returns `$HE_` 载荷中的 4 字节 hash field hex
+*/
+const deriveKuaishouHeHashFieldHex = (signInput, hudrBody) => {
+	const hashInput = `${signInput}HUDR_${hudrBody}`;
+	const digestHex = bytesToLowerHex(deriveKuaishouCts(deriveKuaishouB2sa(hashInput))).slice(0, 8);
+	return bytesToLowerHex(xorByteArrays(hexToSignedBytes(digestHex), KUAISHOU_HE_INPUT_XOR_MASK));
+};
+/**
+* 推导快手签名中的 `$HE_` 段。
+*
+* @param context - 生成 `$HE_` 所需的上下文参数
+* @returns `$HE_` 的最终 hex、中间 hash field 和 preHex
+*/
+const deriveKuaishouHeHex = (context) => {
+	const random48 = Math.floor(context.randomValue * KUAISHOU_HE_RANDOM_MAX);
+	const hashFieldHex = deriveKuaishouHeHashFieldHex(context.signInput, context.hudrBody);
+	const timeXor = BigInt(context.timestamp) ^ KUAISHOU_HE_TIME_XOR_MASK;
+	const preHex = [
+		KUAISHOU_HE_HEADER_HEX,
+		KUAISHOU_HE_VERSION_HEX,
+		KUAISHOU_HE_STARTUP_MARKER_HEX,
+		toLittleEndianHex(context.startupRandom, 6),
+		toLittleEndianHex(random48, 6),
+		KUAISHOU_HE_FIXED_BODY_HEX,
+		toLittleEndianHex(context.count ^ KUAISHOU_HE_COUNTER_XOR_MASK, 4),
+		hashFieldHex,
+		toLittleEndianHex(timeXor, 6),
+		KUAISHOU_HE_TAIL_HEX,
+		computeKuaishouLrcHex(KUAISHOU_HE_TAIL_HEX)
+	].join("");
+	return {
+		finalHex: transformKuaishouHeHex(preHex, computeKuaishouLrcHex(preHex)),
+		hashFieldHex,
+		preHex
+	};
+};
+/**
+* 一次性推导快手完整纯算法签名。
+*
+* 该方法会先生成 `HUDR_`，再拼出 `$HE_`，最终返回完整
+* `HUDR_...$HE_...` 形式的 `__NS_hxfalcon`。
+*
+* @param context - 快手纯算法签名上下文
+* @returns 完整签名结果及关键中间态
+*/
+const deriveKuaishouPureSignature = (context) => {
+	const hudr = deriveKuaishouHudrBody(context);
+	const he = deriveKuaishouHeHex({
+		count: context.count,
+		hudrBody: hudr.body,
+		randomValue: context.randomValue,
+		signInput: context.signInput,
+		startupRandom: context.startupRandom,
+		timestamp: context.timestamp
+	});
+	return {
+		...hudr,
+		he,
+		signResult: `${hudr.full}$HE_${he.finalHex}`
+	};
+};
+/** `$HE_` 最终输出的定长：布局 44 字节 + 末尾 1 字节异或键 */
+const HE_HEX_LENGTH = 90;
+/**
+* 拆开一段 `$HE_`。
+*
+* 最终输出的最后一个字节是**异或键**：它本身是前 44 字节的 LRC 校验，同时把那
+* 44 字节逐个异或成密文 —— 所以解码顺序固定为「拆键 → 还原 → 逐段校验 → 读字段」。
+* 能同时通过两层校验（信封 LRC + 尾段 LRC）与四个布局常量的值，必然是这套装配
+* 顺序产出的；`count` 与时间戳随后原样读回，不需要任何候选输入。
+*
+* 它**不**校验 hash field —— 那四字节绑的是 signInput + HUDR body，候选值给齐了
+* 可用 {@link deriveKuaishouHeHashFieldHex} 自行比对。
+* @param hex - `$HE_` 后面的那段 hex（90 个字符）
+* @returns 拆解结果；布局不符时 `problems` 非空，字段值不可信
+*/
+const decodeKuaishouHe = (hex) => {
+	const problems = [];
+	const fail = (problem) => {
+		problems.push(problem);
+	};
+	if (!/^[0-9a-fA-F]+$/.test(hex)) fail("not hex");
+	if (hex.length !== HE_HEX_LENGTH) fail("length not 90");
+	if (problems.length > 0) return {
+		startupRandom: 0,
+		random: 0,
+		count: 0,
+		timestampMs: 0,
+		hashFieldHex: "",
+		problems
+	};
+	const bytes = hexToSignedBytes(hex.toLowerCase());
+	const key = bytes[bytes.length - 1];
+	const pre = bytes.slice(0, -1).map((byte) => (byte ^ key) & 255);
+	if ((-pre.reduce((total, value) => total + value, 0) & 255) !== (key & 255)) fail("envelope checksum");
+	if ((-pre.slice(36, 43).reduce((total, value) => total + value, 0) & 255) !== pre[43]) fail("tail lrc");
+	const expectBytes = (offset, expectedHex, problem) => {
+		if (!hexToSignedBytes(expectedHex).map((byte) => byte & 255).every((byte, index) => pre[offset + index] === byte)) fail(problem);
+	};
+	expectBytes(0, KUAISHOU_HE_HEADER_HEX, "header magic");
+	expectBytes(2, KUAISHOU_HE_VERSION_HEX, "version");
+	expectBytes(4, KUAISHOU_HE_STARTUP_MARKER_HEX, "startup marker");
+	expectBytes(17, KUAISHOU_HE_FIXED_BODY_HEX, "fixed body");
+	expectBytes(36, KUAISHOU_HE_TAIL_HEX, "tail");
+	const readLE = (offset, size) => {
+		let value = 0;
+		for (let index = 0; index < size; index++) value += pre[offset + index] * 2 ** (8 * index);
+		return value;
+	};
+	const unmaskCounter = (readLE(22, 4) ^ KUAISHOU_HE_COUNTER_XOR_MASK) >>> 0;
+	const unmaskTime = BigInt(Math.trunc(readLE(30, 6))) ^ KUAISHOU_HE_TIME_XOR_MASK;
+	return {
+		startupRandom: Math.trunc(readLE(5, 6)),
+		random: Math.trunc(readLE(11, 6)),
+		count: unmaskCounter,
+		timestampMs: Number(unmaskTime),
+		hashFieldHex: bytesToLowerHex(pre.slice(26, 30)),
+		problems
+	};
+};
+//#endregion
+Object.defineProperty(exports, "ABogus", {
+	enumerable: true,
+	get: function() {
+		return ABogus;
+	}
+});
+Object.defineProperty(exports, "AID", {
+	enumerable: true,
+	get: function() {
+		return AID;
+	}
+});
+Object.defineProperty(exports, "ALPHABETS", {
+	enumerable: true,
+	get: function() {
+		return ALPHABETS;
+	}
+});
+Object.defineProperty(exports, "CALL_BUCKET", {
+	enumerable: true,
+	get: function() {
+		return CALL_BUCKET;
+	}
+});
+Object.defineProperty(exports, "CANVAS_CONSTANT", {
+	enumerable: true,
+	get: function() {
+		return CANVAS_CONSTANT;
+	}
+});
+Object.defineProperty(exports, "CHECK", {
+	enumerable: true,
+	get: function() {
+		return CHECK;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_BROWSER_INFO", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_BROWSER_INFO;
+	}
+});
+Object.defineProperty(exports, "DETECT_FLAGS", {
+	enumerable: true,
+	get: function() {
+		return DETECT_FLAGS;
+	}
+});
+Object.defineProperty(exports, "DIGEST_CHAINS", {
+	enumerable: true,
+	get: function() {
+		return DIGEST_CHAINS;
+	}
+});
+Object.defineProperty(exports, "DOUYIN_MS_TOKEN_LENGTH", {
+	enumerable: true,
+	get: function() {
+		return DOUYIN_MS_TOKEN_LENGTH;
+	}
+});
+Object.defineProperty(exports, "DOUYIN_MS_TOKEN_SIZES", {
+	enumerable: true,
+	get: function() {
+		return DOUYIN_MS_TOKEN_SIZES;
+	}
+});
+Object.defineProperty(exports, "DOUYIN_TTWID", {
+	enumerable: true,
+	get: function() {
+		return DOUYIN_TTWID;
+	}
+});
+Object.defineProperty(exports, "DOUYIN_TTWID_PAYLOAD", {
+	enumerable: true,
+	get: function() {
+		return DOUYIN_TTWID_PAYLOAD;
+	}
+});
+Object.defineProperty(exports, "ENV_FLAGS", {
+	enumerable: true,
+	get: function() {
+		return ENV_FLAGS;
+	}
+});
+Object.defineProperty(exports, "FIELD_ORDER", {
+	enumerable: true,
+	get: function() {
+		return FIELD_ORDER;
+	}
+});
+Object.defineProperty(exports, "FORTNIGHT_EPOCH_MS", {
+	enumerable: true,
+	get: function() {
+		return FORTNIGHT_EPOCH_MS;
+	}
+});
+Object.defineProperty(exports, "HEADER_MAGIC", {
+	enumerable: true,
+	get: function() {
+		return HEADER_MAGIC;
+	}
+});
+Object.defineProperty(exports, "KIND", {
+	enumerable: true,
+	get: function() {
+		return KIND;
+	}
+});
+Object.defineProperty(exports, "MS_TOKEN_ALPHABET", {
+	enumerable: true,
+	get: function() {
+		return MS_TOKEN_ALPHABET;
+	}
+});
+Object.defineProperty(exports, "PAGE_ID", {
+	enumerable: true,
+	get: function() {
+		return PAGE_ID;
+	}
+});
+Object.defineProperty(exports, "PAYLOAD_KEY", {
+	enumerable: true,
+	get: function() {
+		return PAYLOAD_KEY$1;
+	}
+});
+Object.defineProperty(exports, "REASON", {
+	enumerable: true,
+	get: function() {
+		return REASON;
+	}
+});
+Object.defineProperty(exports, "SALT", {
+	enumerable: true,
+	get: function() {
+		return SALT;
+	}
+});
+Object.defineProperty(exports, "SDK_VERSION", {
+	enumerable: true,
+	get: function() {
+		return SDK_VERSION;
+	}
+});
+Object.defineProperty(exports, "SECSDK_SIG_KEY", {
+	enumerable: true,
+	get: function() {
+		return SECSDK_SIG_KEY;
+	}
+});
+Object.defineProperty(exports, "SM3_IV", {
+	enumerable: true,
+	get: function() {
+		return SM3_IV;
+	}
+});
+Object.defineProperty(exports, "TRIPWIRE_LOCKED", {
+	enumerable: true,
+	get: function() {
+		return TRIPWIRE_LOCKED;
+	}
+});
+Object.defineProperty(exports, "TTWID_REGISTER_URL", {
+	enumerable: true,
+	get: function() {
+		return TTWID_REGISTER_URL;
+	}
+});
+Object.defineProperty(exports, "VERIFY_FP_ALPHABET", {
+	enumerable: true,
+	get: function() {
+		return VERIFY_FP_ALPHABET;
+	}
+});
+Object.defineProperty(exports, "VERIFY_FP_LENGTH", {
+	enumerable: true,
+	get: function() {
+		return VERIFY_FP_LENGTH;
+	}
+});
+Object.defineProperty(exports, "WEBSIGN_CONST", {
+	enumerable: true,
+	get: function() {
+		return WEBSIGN_CONST;
+	}
+});
+Object.defineProperty(exports, "XBogus", {
+	enumerable: true,
+	get: function() {
+		return XBogus;
+	}
+});
+Object.defineProperty(exports, "a_bogus_default", {
+	enumerable: true,
+	get: function() {
+		return a_bogus_default;
+	}
+});
+Object.defineProperty(exports, "applySecsdkWebSign", {
+	enumerable: true,
+	get: function() {
+		return applySecsdkWebSign;
+	}
+});
+Object.defineProperty(exports, "browserInfoFromScreen", {
+	enumerable: true,
+	get: function() {
+		return browserInfoFromScreen;
+	}
+});
+Object.defineProperty(exports, "buildBrowserInfo", {
+	enumerable: true,
+	get: function() {
+		return buildBrowserInfo;
+	}
+});
+Object.defineProperty(exports, "canary", {
+	enumerable: true,
+	get: function() {
+		return canary;
+	}
+});
+Object.defineProperty(exports, "canonicalQuery", {
+	enumerable: true,
+	get: function() {
+		return canonicalQuery;
+	}
+});
+Object.defineProperty(exports, "chainBytes", {
+	enumerable: true,
+	get: function() {
+		return chainBytes;
+	}
+});
+Object.defineProperty(exports, "computeWbiSignature", {
+	enumerable: true,
+	get: function() {
+		return computeWbiSignature;
+	}
+});
+Object.defineProperty(exports, "createWbiSigner", {
+	enumerable: true,
+	get: function() {
+		return createWbiSigner;
+	}
+});
+Object.defineProperty(exports, "decode", {
+	enumerable: true,
+	get: function() {
+		return decode;
+	}
+});
+Object.defineProperty(exports, "decodeABogus", {
+	enumerable: true,
+	get: function() {
+		return decodeABogus;
+	}
+});
+Object.defineProperty(exports, "decodeBase64", {
+	enumerable: true,
+	get: function() {
+		return decodeBase64;
+	}
+});
+Object.defineProperty(exports, "decodeKuaishouHe", {
+	enumerable: true,
+	get: function() {
+		return decodeKuaishouHe;
+	}
+});
+Object.defineProperty(exports, "decodeUrl", {
+	enumerable: true,
+	get: function() {
+		return decodeUrl;
+	}
+});
+Object.defineProperty(exports, "decodeVerifyFp", {
+	enumerable: true,
+	get: function() {
+		return decodeVerifyFp;
+	}
+});
+Object.defineProperty(exports, "decodeXBogus", {
+	enumerable: true,
+	get: function() {
+		return decodeXBogus;
+	}
+});
+Object.defineProperty(exports, "deriveKuaishouHeHashFieldHex", {
+	enumerable: true,
+	get: function() {
+		return deriveKuaishouHeHashFieldHex;
+	}
+});
+Object.defineProperty(exports, "deriveKuaishouHeHex", {
+	enumerable: true,
+	get: function() {
+		return deriveKuaishouHeHex;
+	}
+});
+Object.defineProperty(exports, "deriveKuaishouPureSignature", {
+	enumerable: true,
+	get: function() {
+		return deriveKuaishouPureSignature;
+	}
+});
+Object.defineProperty(exports, "diagnoseSalt", {
+	enumerable: true,
+	get: function() {
+		return diagnoseSalt;
+	}
+});
+Object.defineProperty(exports, "digestOf", {
+	enumerable: true,
+	get: function() {
+		return digestOf;
+	}
+});
+Object.defineProperty(exports, "digestWith", {
+	enumerable: true,
+	get: function() {
+		return digestWith;
+	}
+});
+Object.defineProperty(exports, "encodeBase64", {
+	enumerable: true,
+	get: function() {
+		return encodeBase64;
+	}
+});
+Object.defineProperty(exports, "extractKey", {
+	enumerable: true,
+	get: function() {
+		return extractKey;
+	}
+});
+Object.defineProperty(exports, "extractUifidFromCookie", {
+	enumerable: true,
+	get: function() {
+		return extractUifidFromCookie;
+	}
+});
+Object.defineProperty(exports, "genFalseMsToken", {
+	enumerable: true,
+	get: function() {
+		return genFalseMsToken;
+	}
+});
+Object.defineProperty(exports, "genSVWebId", {
+	enumerable: true,
+	get: function() {
+		return genSVWebId;
+	}
+});
+Object.defineProperty(exports, "genVerifyFp", {
+	enumerable: true,
+	get: function() {
+		return genVerifyFp;
+	}
+});
+Object.defineProperty(exports, "getCookieValue", {
+	enumerable: true,
+	get: function() {
+		return getCookieValue;
+	}
+});
+Object.defineProperty(exports, "identify", {
+	enumerable: true,
+	get: function() {
+		return identify;
+	}
+});
+Object.defineProperty(exports, "isDecodeProblem", {
+	enumerable: true,
+	get: function() {
+		return isDecodeProblem;
+	}
+});
+Object.defineProperty(exports, "isSecsdkProtected", {
+	enumerable: true,
+	get: function() {
+		return isSecsdkProtected;
+	}
+});
+Object.defineProperty(exports, "jsBytes", {
+	enumerable: true,
+	get: function() {
+		return jsBytes;
+	}
+});
+Object.defineProperty(exports, "msTokenPayload", {
+	enumerable: true,
+	get: function() {
+		return msTokenPayload;
+	}
+});
+Object.defineProperty(exports, "rc4", {
+	enumerable: true,
+	get: function() {
+		return rc4$1;
+	}
+});
+Object.defineProperty(exports, "recoverSignedQuery", {
+	enumerable: true,
+	get: function() {
+		return recoverSignedQuery;
+	}
+});
+Object.defineProperty(exports, "signSecsdkWebQuery", {
+	enumerable: true,
+	get: function() {
+		return signSecsdkWebQuery;
+	}
+});
+Object.defineProperty(exports, "signSecsdkWebUrl", {
+	enumerable: true,
+	get: function() {
+		return signSecsdkWebUrl;
+	}
+});
+Object.defineProperty(exports, "signXBogus", {
+	enumerable: true,
+	get: function() {
+		return signXBogus;
+	}
+});
+Object.defineProperty(exports, "signedQueryOf", {
+	enumerable: true,
+	get: function() {
+		return signedQueryOf;
+	}
+});
+Object.defineProperty(exports, "sm3Hash", {
+	enumerable: true,
+	get: function() {
+		return sm3Hash;
+	}
+});
+Object.defineProperty(exports, "sm3Hexdigest", {
+	enumerable: true,
+	get: function() {
+		return sm3Hexdigest;
+	}
+});
+Object.defineProperty(exports, "sm3ToArray", {
+	enumerable: true,
+	get: function() {
+		return sm3ToArray;
+	}
+});
+Object.defineProperty(exports, "structureError", {
+	enumerable: true,
+	get: function() {
+		return structureError;
+	}
+});
+Object.defineProperty(exports, "toBase36", {
+	enumerable: true,
+	get: function() {
+		return toBase36;
+	}
+});
+Object.defineProperty(exports, "unmaskPair", {
+	enumerable: true,
+	get: function() {
+		return unmaskPair;
+	}
+});
+Object.defineProperty(exports, "userAgentDigest", {
+	enumerable: true,
+	get: function() {
+		return userAgentDigest;
+	}
+});
+Object.defineProperty(exports, "xBogusStructureError", {
+	enumerable: true,
+	get: function() {
+		return xBogusStructureError;
+	}
+});