From ddb8d1be43bb28e5a18770095595c4442604f289 Mon Sep 17 00:00:00 2001 From: cyfung1031 <44498510+cyfung1031@users.noreply.github.com> Date: Fri, 9 Jan 2026 21:57:48 +0900 Subject: [PATCH] charset detection --- package.json | 1 + pnpm-lock.yaml | 26 +-- src/pages/install/App.tsx | 4 +- src/pkg/utils/encoding.test.ts | 399 +++++++++++++++++++++++++++++++-- src/pkg/utils/encoding.ts | 89 +++++++- 5 files changed, 474 insertions(+), 45 deletions(-) diff --git a/package.json b/package.json index 46cdfa0c7..315dba9b2 100644 --- a/package.json +++ b/package.json @@ -81,6 +81,7 @@ "eslint-plugin-react-hooks": "^5.2.0", "eslint-plugin-userscripts": "^0.5.6", "globals": "^16.5.0", + "iconv-lite": "^0.7.2", "jsdom": "^26.1.0", "jszip": "^3.10.1", "mock-xmlhttprequest": "^8.4.1", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 842127acc..4f99ea473 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -171,6 +171,9 @@ importers: globals: specifier: ^16.5.0 version: 16.5.0 + iconv-lite: + specifier: ^0.7.2 + version: 0.7.2 jsdom: specifier: ^26.1.0 version: 26.1.0 @@ -902,67 +905,56 @@ packages: resolution: {integrity: sha512-+xmiDGGaSfIIOXMzkhJ++Oa0Gwvl9oXUeIiwarsdRXSe27HUIvjbSIpPxvnNsRebsNdUo7uAiQVgBD1hVriwSQ==} cpu: [arm] os: [linux] - libc: [glibc] '@rollup/rollup-linux-arm-musleabihf@4.44.2': resolution: {integrity: sha512-bDHvhzOfORk3wt8yxIra8N4k/N0MnKInCW5OGZaeDYa/hMrdPaJzo7CSkjKZqX4JFUWjUGm88lI6QJLCM7lDrA==} cpu: [arm] os: [linux] - libc: [musl] '@rollup/rollup-linux-arm64-gnu@4.44.2': resolution: {integrity: sha512-NMsDEsDiYghTbeZWEGnNi4F0hSbGnsuOG+VnNvxkKg0IGDvFh7UVpM/14mnMwxRxUf9AdAVJgHPvKXf6FpMB7A==} cpu: [arm64] os: [linux] - libc: [glibc] '@rollup/rollup-linux-arm64-musl@4.44.2': resolution: {integrity: sha512-lb5bxXnxXglVq+7imxykIp5xMq+idehfl+wOgiiix0191av84OqbjUED+PRC5OA8eFJYj5xAGcpAZ0pF2MnW+A==} cpu: [arm64] os: [linux] - libc: [musl] '@rollup/rollup-linux-loongarch64-gnu@4.44.2': resolution: {integrity: sha512-Yl5Rdpf9pIc4GW1PmkUGHdMtbx0fBLE1//SxDmuf3X0dUC57+zMepow2LK0V21661cjXdTn8hO2tXDdAWAqE5g==} cpu: [loong64] os: [linux] - libc: [glibc] '@rollup/rollup-linux-powerpc64le-gnu@4.44.2': resolution: {integrity: sha512-03vUDH+w55s680YYryyr78jsO1RWU9ocRMaeV2vMniJJW/6HhoTBwyyiiTPVHNWLnhsnwcQ0oH3S9JSBEKuyqw==} cpu: [ppc64] os: [linux] - libc: [glibc] '@rollup/rollup-linux-riscv64-gnu@4.44.2': resolution: {integrity: sha512-iYtAqBg5eEMG4dEfVlkqo05xMOk6y/JXIToRca2bAWuqjrJYJlx/I7+Z+4hSrsWU8GdJDFPL4ktV3dy4yBSrzg==} cpu: [riscv64] os: [linux] - libc: [glibc] '@rollup/rollup-linux-riscv64-musl@4.44.2': resolution: {integrity: sha512-e6vEbgaaqz2yEHqtkPXa28fFuBGmUJ0N2dOJK8YUfijejInt9gfCSA7YDdJ4nYlv67JfP3+PSWFX4IVw/xRIPg==} cpu: [riscv64] os: [linux] - libc: [musl] '@rollup/rollup-linux-s390x-gnu@4.44.2': resolution: {integrity: sha512-evFOtkmVdY3udE+0QKrV5wBx7bKI0iHz5yEVx5WqDJkxp9YQefy4Mpx3RajIVcM6o7jxTvVd/qpC1IXUhGc1Mw==} cpu: [s390x] os: [linux] - libc: [glibc] '@rollup/rollup-linux-x64-gnu@4.44.2': resolution: {integrity: sha512-/bXb0bEsWMyEkIsUL2Yt5nFB5naLAwyOWMEviQfQY1x3l5WsLKgvZf66TM7UTfED6erckUVUJQ/jJ1FSpm3pRQ==} cpu: [x64] os: [linux] - libc: [glibc] '@rollup/rollup-linux-x64-musl@4.44.2': resolution: {integrity: sha512-3D3OB1vSSBXmkGEZR27uiMRNiwN08/RVAcBKwhUYPaiZ8bcvdeEwWPvbnXvvXHY+A/7xluzcN+kaiOFNiOZwWg==} cpu: [x64] os: [linux] - libc: [musl] '@rollup/rollup-win32-arm64-msvc@4.44.2': resolution: {integrity: sha512-VfU0fsMK+rwdK8mwODqYeM2hDrF2WiHaSmCBrS7gColkQft95/8tphyzv2EupVxn3iE0FI78wzffoULH1G+dkw==} @@ -993,25 +985,21 @@ packages: resolution: {integrity: sha512-n7UGSBzv7PiX+V1Q2bY3S1XWyN3RCykCQUgfhZ+xWietCM/1349jgN7DoXKPllqlof1GPGBjziHU0sQZTC4tag==} cpu: [arm64] os: [linux] - libc: [glibc] '@rspack/binding-linux-arm64-musl@1.6.1': resolution: {integrity: sha512-P7nx0jsKxx7g3QAnH9UnJDGVgs1M2H7ZQl68SRyrs42TKOd9Md22ynoMIgCK1zoy+skssU6MhWptluSggXqSrA==} cpu: [arm64] os: [linux] - libc: [musl] '@rspack/binding-linux-x64-gnu@1.6.1': resolution: {integrity: sha512-SdiurC1bV/QHnj7rmrBYJLdsat3uUDWl9KjkVjEbtc8kQV0Ri4/vZRH0nswgzx7hZNY2j0jYuCm5O8+3qeJEMg==} cpu: [x64] os: [linux] - libc: [glibc] '@rspack/binding-linux-x64-musl@1.6.1': resolution: {integrity: sha512-JoSJu29nV+auOePhe8x2Fzqxiga1YGNcOMWKJ5Uj8rHBZ8FPAiiE+CpLG8TwfpHsivojrY/sy6fE8JldYLV5TQ==} cpu: [x64] os: [linux] - libc: [musl] '@rspack/binding-wasm32-wasi@1.6.1': resolution: {integrity: sha512-u5NiSHxM7LtIo4cebq/hQPJ9o39u127am3eVJHDzdmBVhTYYO5l7XVUnFmcU8hNHuj/4lJzkFviWFbf3SaRSYA==} @@ -2564,6 +2552,10 @@ packages: resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} engines: {node: '>=0.10.0'} + iconv-lite@0.7.2: + resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==} + engines: {node: '>=0.10.0'} + ieee754@1.2.1: resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} @@ -6962,6 +6954,10 @@ snapshots: dependencies: safer-buffer: 2.1.2 + iconv-lite@0.7.2: + dependencies: + safer-buffer: 2.1.2 + ieee754@1.2.1: {} ignore@5.3.2: {} diff --git a/src/pages/install/App.tsx b/src/pages/install/App.tsx index 8801db4b1..7d2a6038d 100644 --- a/src/pages/install/App.tsx +++ b/src/pages/install/App.tsx @@ -33,7 +33,7 @@ import { CACHE_KEY_SCRIPT_INFO } from "@App/app/cache_key"; import { cacheInstance } from "@App/app/cache"; import { formatBytes, prettyUrl } from "@App/pkg/utils/utils"; import { ScriptIcons } from "../options/routes/utils"; -import { detectEncoding } from "@App/pkg/utils/encoding"; +import { bytesDecode, detectEncoding } from "@App/pkg/utils/encoding"; const backgroundPromptShownKey = "background_prompt_shown"; @@ -118,7 +118,7 @@ const fetchScriptBody = async (url: string, { onProgress }: { [key: string]: any // 使用检测到的 charset 解码 let code; try { - code = new TextDecoder(encode).decode(chunksAll); + code = bytesDecode(encode, chunksAll); } catch (e: any) { console.warn(`Failed to decode response with charset ${encode}: ${e.message}`); // 回退到 UTF-8 diff --git a/src/pkg/utils/encoding.test.ts b/src/pkg/utils/encoding.test.ts index a62e4a8e8..fa728d7b2 100644 --- a/src/pkg/utils/encoding.test.ts +++ b/src/pkg/utils/encoding.test.ts @@ -1,5 +1,7 @@ import { describe, it, expect, vi } from "vitest"; -import { parseCharsetFromContentType, detectEncoding } from "./encoding"; +import { parseCharsetFromContentType, detectEncoding, bytesDecode } from "./encoding"; +import { base64ToUint8 } from "./datatype"; +import iconv from "iconv-lite"; describe("encoding detection", () => { describe("parseCharsetFromContentType", () => { @@ -35,6 +37,150 @@ describe("encoding detection", () => { }); describe("detectEncoding", () => { + // Test Tool: https://r12a.github.io/app-encodings/ + it("Basic Test", () => { + let utf8Data: Uint8Array; + utf8Data = new TextEncoder().encode("a"); + expect(detectEncoding(utf8Data, null)).toBe("ascii"); + utf8Data = new TextEncoder().encode("a1"); + expect(detectEncoding(utf8Data, null)).toBe("ascii"); + utf8Data = new TextEncoder().encode("a"); + expect(detectEncoding(utf8Data, "text/javascript; charset=utf-8")).toBe("utf-8"); + utf8Data = new TextEncoder().encode("a1"); + expect(detectEncoding(utf8Data, "text/javascript; charset=big5")).toBe("big5"); + utf8Data = new TextEncoder().encode("a1"); + expect(detectEncoding(utf8Data, "text/javascript; charset=big4")).toBe("ascii"); + utf8Data = new TextEncoder().encode("你"); + expect(detectEncoding(utf8Data, "text/javascript; charset=big4")).toBe("utf-8"); + }); + it("Charset Detection Test (1)", () => { + let utf8Data: Uint8Array; + utf8Data = new Uint8Array([ + 0xa7, + 0xda, // 我 + 0xb7, + 0x52, // 愛 + 0x20, // space + 0x43, // C + 0x20, // space + 0xbb, + 0x79, // 語 + 0xa8, + 0xec, // 言 + ]); + expect(detectEncoding(utf8Data, null)).toBe("big5"); + + // 這是一個Big5測試句子，包含English與中文123。 + utf8Data = Uint8Array.from([ + 0xb3, 0x6f, 0xac, 0x4f, 0xa4, 0x40, 0xad, 0xd3, 0x42, 0x69, 0x67, 0x35, 0xb4, 0xfa, 0xb8, 0xd5, 0xa5, 0xdc, + 0xa4, 0x40, 0xa5, 0x5f, 0xa6, 0x72, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0xbb, 0x50, 0xa4, 0xa4, 0x31, + 0x32, 0x33, 0xa1, 0x43, + ]); + expect(detectEncoding(utf8Data, null)).toBe("big5"); + + // 这是一个GBK编码测试Sentence混合12345。 + utf8Data = Uint8Array.from([ + 0xd5, 0xe2, 0xca, 0xc7, 0xd2, 0xbb, 0xb8, 0xf6, 0x47, 0x42, 0x4b, 0xb1, 0xe0, 0xc2, 0xeb, 0xb2, 0xe2, 0xca, + 0xd4, 0x53, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x63, 0x65, 0xbb, 0xec, 0xba, 0xcf, 0x31, 0x32, 0x33, 0x34, 0x35, + 0xa1, 0xa3, + ]); + expect(detectEncoding(utf8Data, null)).toBe("gb18030"); + + // これはShiftJISのテスト文章withEnglish123 + utf8Data = Uint8Array.from([ + 0x82, 0xb1, 0x82, 0xea, 0x82, 0xcd, 0x53, 0x68, 0x69, 0x66, 0x74, 0x4a, 0x49, 0x53, 0x82, 0xcc, 0x83, 0x65, + 0x83, 0x58, 0x83, 0x67, 0x95, 0xb6, 0x8f, 0x9c, 0x77, 0x69, 0x74, 0x68, 0x45, 0x6e, 0x67, 0x6c, 0x69, 0x73, + 0x68, 0x31, 0x32, 0x33, + ]); + expect(detectEncoding(utf8Data, null)).toBe("shift_jis"); + + // 이것은EUC-KR인코딩테스트문장Test123 + utf8Data = Uint8Array.from([ + 0xc0, 0xcc, 0xb0, 0xcd, 0xc0, 0xba, 0x45, 0x55, 0x43, 0x2d, 0x4b, 0x52, 0xc0, 0xce, 0xc4, 0xda, 0xb5, 0xf9, + 0xc5, 0xd7, 0xbd, 0xba, 0xc6, 0xae, 0xb9, 0xae, 0xc0, 0xe5, 0x54, 0x65, 0x73, 0x74, 0x31, 0x32, 0x33, + ]); + expect(detectEncoding(utf8Data, null)).toBe("euc-kr"); + + // iso-8859-2: Café naïve résumé with ASCII 12345 + utf8Data = Uint8Array.from([ + 0x43, 0x61, 0x66, 0xe9, 0x20, 0x6e, 0x61, 0xef, 0x76, 0x65, 0x20, 0x72, 0xe9, 0x73, 0x75, 0x6d, 0xe9, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x20, 0x41, 0x53, 0x43, 0x49, 0x49, 0x20, 0x31, 0x32, 0x33, 0x34, 0x35, + ]); + expect(detectEncoding(utf8Data, null)).toBe("iso-8859-2"); + + // utf-8: Hello 世界, this is UTF8 測試 + utf8Data = Uint8Array.from([ + 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0xe4, 0xb8, 0x96, 0xe7, 0x95, 0x8c, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x69, 0x73, 0x20, 0x55, 0x54, 0x46, 0x38, 0x20, 0xe6, 0xb8, 0xac, 0xe8, 0xa9, 0xa6, + ]); + expect(detectEncoding(utf8Data, null)).toBe("utf-8"); + + // windows-1252: This costs 50€ — quite “expensive” indeed. + utf8Data = Uint8Array.from([ + 84, 104, 105, 115, 32, 99, 111, 115, 116, 115, 32, 53, 48, 128, 32, 151, 32, 113, 117, 105, 116, 101, 32, 101, + 120, 112, 101, 110, 115, 105, 118, 101, 148, 32, 105, 110, 100, 101, 101, 100, 46, + ]); + expect(detectEncoding(utf8Data, null)).toBe("windows-1252"); + + // iso-8859-1: This costs 50€ — quite “expensive” indeed. + utf8Data = Uint8Array.from([ + 69, 108, 32, 110, 105, 241, 111, 32, 99, 111, 109, 105, 243, 32, 112, 105, 241, 97, 116, 97, 32, 121, 32, 116, + 111, 109, 243, 32, 99, 97, 102, 233, 46, + ]); + expect(detectEncoding(utf8Data, null)).toBe("iso-8859-1"); + + // koi8-r: Привет мир 123 ABC тест + utf8Data = Uint8Array.from([ + 208, 210, 201, 215, 197, 212, 32, 205, 201, 210, 32, 49, 50, 51, 32, 65, 66, 67, 32, 212, 197, 211, 212, + ]); + expect(detectEncoding(utf8Data, null)).toBe("koi8-r"); + }); + + it("Charset Detection Test (2)", () => { + // Sentence (>10 chars): "Hello BOM world." + + // UTF-8 BOM (EF BB BF) + const utf8_bom = new Uint8Array([ + 239, 187, 191, 72, 101, 108, 108, 111, 32, 66, 79, 77, 32, 119, 111, 114, 108, 100, 46, + ]); + expect(detectEncoding(utf8_bom, null)).toBe("utf-8"); + expect(bytesDecode("utf-8", utf8_bom)).toBe("Hello BOM world."); + + // UTF-16 LE BOM (FF FE) + const utf16le_bom = new Uint8Array([ + 255, 254, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 32, 0, 66, 0, 79, 0, 77, 0, 32, 0, 119, 0, 111, 0, 114, 0, 108, + 0, 100, 0, 46, 0, + ]); + expect(detectEncoding(utf16le_bom, null)).toBe("utf-16le"); + expect(bytesDecode("utf-16le", utf16le_bom)).toBe("Hello BOM world."); + + // UTF-16 BE BOM (FE FF) + const utf16be_bom = new Uint8Array([ + 254, 255, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 32, 0, 66, 0, 79, 0, 77, 0, 32, 0, 119, 0, 111, 0, 114, 0, + 108, 0, 100, 0, 46, + ]); + expect(detectEncoding(utf16be_bom, null)).toBe("utf-16be"); + expect(bytesDecode("utf-16be", utf16be_bom)).toBe("Hello BOM world."); + + // UTF-32 LE BOM (FF FE 00 00) + const utf32le_bom = new Uint8Array([ + 255, 254, 0, 0, 72, 0, 0, 0, 101, 0, 0, 0, 108, 0, 0, 0, 108, 0, 0, 0, 111, 0, 0, 0, 32, 0, 0, 0, 66, 0, 0, 0, + 79, 0, 0, 0, 77, 0, 0, 0, 32, 0, 0, 0, 119, 0, 0, 0, 111, 0, 0, 0, 114, 0, 0, 0, 108, 0, 0, 0, 100, 0, 0, 0, 46, + 0, 0, 0, + ]); + expect(detectEncoding(utf32le_bom, null)).toBe("utf-32le"); + expect(bytesDecode("utf-32le", utf32le_bom)).toBe("Hello BOM world."); + + // UTF-32 BE BOM (00 00 FE FF) + const utf32be_bom = new Uint8Array([ + 0, 0, 254, 255, 0, 0, 0, 72, 0, 0, 0, 101, 0, 0, 0, 108, 0, 0, 0, 108, 0, 0, 0, 111, 0, 0, 0, 32, 0, 0, 0, 66, + 0, 0, 0, 79, 0, 0, 0, 77, 0, 0, 0, 32, 0, 0, 0, 119, 0, 0, 0, 111, 0, 0, 0, 114, 0, 0, 0, 108, 0, 0, 0, 100, 0, + 0, 0, 46, + ]); + expect(detectEncoding(utf32be_bom, null)).toBe("utf-32be"); + expect(bytesDecode("utf-32be", utf32be_bom)).toBe("Hello BOM world."); + }); + it("should prioritize valid charset from Content-Type header", () => { const utf8Data = new TextEncoder().encode("hello world"); expect(detectEncoding(utf8Data, "text/javascript; charset=utf-8")).toBe("utf-8"); @@ -59,7 +205,7 @@ describe("encoding detection", () => { const emptyData = new Uint8Array(0); const encoding = detectEncoding(emptyData, null); // 空数据时，chardet 可能返回 ascii 或其他编码，但都应该是有效的 - expect(encoding).toBeTruthy(); + expect(["utf-8", "ascii", "windows-1252"]).toContain(encoding); expect(() => new TextDecoder(encoding)).not.toThrow(); }); @@ -76,21 +222,181 @@ describe("encoding detection", () => { expect(["utf-8", "ascii", "windows-1252"]).toContain(encoding); }); - it("should handle GBK encoded data", () => { + it("should NOT detect Shift_JIS when non-ASCII appears only after 16KB (1)", () => { + const buf = new Uint8Array(40 * 1024); + + // 前 18KB → 纯 ASCII（看起来像 UTF-8 / ASCII） + buf.fill(0x61, 0, 18 * 1024); // 'a' * 18KB + + // 18KB 之后 → 典型的 Shift_JIS 专用字节序列 + // 0x82 0xA0 在 Shift_JIS 中表示字符“㈠” + // 如果被误当成 UTF-8，这些字节是非法的 + const offset = 18 * 1024; + buf[offset] = 0x82; + buf[offset + 1] = 0xa0; + buf[offset + 2] = 0x82; + buf[offset + 3] = 0xa9; // 更多类似 Shift_JIS 的双字节组合 + + const encoding = detectEncoding(buf, null); + + // 如果实现正确地将采样限制在约 8KB 以内 → 应判断为 UTF-8 / ASCII + expect(["utf-8", "ascii", "windows-1252"]).toContain(encoding); + // 如果错误地读取了整个 buffer → 可能会误判为 shift_jis + expect(encoding).not.toBe("shift_jis"); + }); + + it("should NOT detect Shift_JIS when non-ASCII appears only after 16KB (2)", () => { + const buf = new Uint8Array(40 * 1024); + + // 前 18KB → 纯 ASCII（仍在 8KB 采样范围内） + buf.fill(0x61, 0, 18 * 1024); // 'a' * 14KB + + // 3KB 之后 → 出现典型的 Shift_JIS 字节 + const offset = 14 * 1024; + buf[offset] = 0x82; + buf[offset + 1] = 0xa0; + buf[offset + 2] = 0x82; + buf[offset + 3] = 0xa9; // 更多 Shift_JIS 风格字节对 + + const encoding = detectEncoding(buf, null); + + // 因为 Shift_JIS 字节出现在 8KB 采样范围内，应被正确识别 + expect(encoding).toBe("shift_jis"); + }); + + it("should handle GBK encoded data (1)", () => { // GBK 编码的 "你好" (这是一个简化的测试，实际 GBK 编码更复杂) // 注意：在浏览器环境中，GBK 编码可能被识别为其他兼容编码 - const gbkLikeData = new Uint8Array([0xc4, 0xe3, 0xba, 0xc3]); // "你好" in GBK + // "你好" in GBK + const gbkLikeData = new Uint8Array([0xc4, 0xe3, 0xba, 0xc3]); const encoding = detectEncoding(gbkLikeData, null); - // chardet 可能识别为 GBK、Shift_JIS 或相关的东亚编码 - expect(encoding).toBeTruthy(); + // chardet 可能识别为 GBK、Shift_JIS、euc-jp 或相关的东亚编码 + expect(["gbk", "big5"]).toContain(encoding); + expect(() => new TextDecoder(encoding)).not.toThrow(); + }); + + it("should handle GBK encoded data (2)", () => { + // "你好，世界！"(GBK) + const gbkLikeData = new Uint8Array([0xc4, 0xe3, 0xba, 0xc3, 0xa3, 0xac, 0xca, 0xc0, 0xbd, 0xe7, 0xa3, 0xa1]); + const encoding = detectEncoding(gbkLikeData, null); + // chardet 可能识别为 GBK、Shift_JIS、euc-jp 或相关的东亚编码 + expect(["gbk", "big5"]).toContain(encoding); + expect(() => new TextDecoder(encoding)).not.toThrow(); + }); + + it("should handle GBK encoded data (GB2312)", () => { + // GB2312: 中文测试 + const gb2312Data = new Uint8Array([ + // 中 + 0xd6, 0xd0, + // 文 + 0xce, 0xc4, + // 测 + 0xb2, 0xe2, + // 试 + 0xca, 0xd4, + ]); + const encoding = detectEncoding(gb2312Data, null); + // chardet 可能识别为 GBK、Shift_JIS、euc-jp 或相关的东亚编码 + expect(["gbk", "gb18030", "big5"]).toContain(encoding); + expect(() => new TextDecoder(encoding)).not.toThrow(); + }); + + it("should handle GBK encoded data (GBK)", () => { + // GBK: 中文测试扩展凉 + const gbkData = new Uint8Array([ + // 中 + 0xd6, 0xd0, + // 文 + 0xce, 0xc4, + // 测 + 0xb2, 0xe2, + // 试 + 0xca, 0xd4, + // 扩 + 0xc0, 0xa9, + // 展 + 0xd5, 0xb9, + // 凉 + 0xfd, 0x9d, + ]); + const encoding = detectEncoding(gbkData, null); + // chardet 可能识别为 GBK、Shift_JIS、euc-jp 或相关的东亚编码 + expect(["gbk", "gb18030", "big5"]).toContain(encoding); expect(() => new TextDecoder(encoding)).not.toThrow(); }); + it("should handle GBK encoded data (GB18030)", () => { + // GB18030: 中文测试扺 + const gb18030Data1 = new Uint8Array([ + // 中 + 0xd6, 0xd0, + // 文 + 0xce, 0xc4, + // 测 + 0xb2, 0xe2, + // 试 + 0xca, 0xd4, + // 扺 + 0x92, 0x57, + ]); + const encoding1 = detectEncoding(gb18030Data1, null); + // chardet 可能识别为 GBK、Shift_JIS、euc-jp 或相关的东亚编码 + expect(["gbk", "gb18030", "big5"]).toContain(encoding1); + expect(() => new TextDecoder(encoding1)).not.toThrow(); + + // GB18030: 中文ὒ测试扺 + const gb18030Data2 = new Uint8Array([ + // 中 + 0xd6, 0xd0, + // 文 + 0xce, 0xc4, + // ὒ + 0x81, 0x36, 0x92, 0x32, + // 测 + 0xb2, 0xe2, + // 试 + 0xca, 0xd4, + // 扺 + 0x92, 0x57, + ]); + const encoding2 = detectEncoding(gb18030Data2, null); + // chardet 可能识别为 GBK、Shift_JIS、euc-jp 或相关的东亚编码 + expect(["gbk", "gb18030"]).toContain(encoding2); + expect(() => new TextDecoder(encoding2)).not.toThrow(); + }); + + it("detect GBK", () => { + // not BIG5 + // gb18030/gbk: 璹亽 + const gbkLikeData = new Uint8Array([0xad, 0x71, 0x81, 0x92]); + const encoding = detectEncoding(gbkLikeData, null); + expect(["gbk", "gb18030"]).toContain(encoding); + expect(() => new TextDecoder(encoding)).not.toThrow(); + expect(new TextDecoder(encoding).decode(gbkLikeData)).toBe("璹亽"); + }); + it("should handle ISO-8859-1 encoded data", () => { // ISO-8859-1 特有字符（扩展 ASCII） - const iso88591Data = new Uint8Array([0xe9, 0xe8, 0xe0, 0xe7]); // é è à ç + // "Café déjà vu, élève français, à bientôt!" + const iso88591Data = new Uint8Array([ + // Café + 0x43, 0x61, 0x66, 0xe9, 0x20, + // déjà + 0x64, 0xe9, 0x6a, 0xe0, 0x20, + // vu, + 0x76, 0x75, 0x2c, 0x20, + // élève + 0xe9, 0x6c, 0xe8, 0x76, 0x65, 0x20, + // français, + 0x66, 0x72, 0x61, 0x6e, 0xe7, 0x61, 0x69, 0x73, 0x2c, 0x20, + // à + 0xe0, 0x20, + // bientôt! + 0x62, 0x69, 0x65, 0x6e, 0x74, 0xf4, 0x74, 0x21, + ]); const encoding = detectEncoding(iso88591Data, null); - expect(encoding).toBeTruthy(); + expect(encoding).toBe("iso-8859-1"); }); it("should validate detected encoding is supported by TextDecoder", () => { @@ -115,14 +421,51 @@ describe("encoding detection", () => { expect(detectEncoding(data, "text/javascript; charset=GBK")).toBe("gbk"); }); - it("should handle Windows-1252 encoded data", () => { - // Windows-1252 特有字符 - const win1252Data = new Uint8Array([0x80, 0x82, 0x83, 0x84]); // € ‚ ƒ „ + it("should handle Windows-1252 encoded data (1)", () => { + // Windows-1252 特有字符（扩展 ASCII） + // “Price is 50€ – Café™ déjà vu” + const win1252Data = new Uint8Array([ + // “ + 0x93, + // Price␠ + 0x50, 0x72, 0x69, 0x63, 0x65, 0x20, + // is␠ + 0x69, 0x73, 0x20, + // 50 + 0x35, 0x30, + // € + 0x80, 0x20, + // – + 0x96, 0x20, + // Café + 0x43, 0x61, 0x66, 0xe9, + // ™ + 0x99, 0x20, + // déjà + 0x64, 0xe9, 0x6a, 0xe0, 0x20, + // vu + 0x76, 0x75, + // ” + 0x94, + ]); const encoding = detectEncoding(win1252Data, null); - expect(encoding).toBeTruthy(); - // chardet 应该能检测出编码或回退到有效的编码 - // Shift_JIS 也是一个有效的编码，chardet 可能会识别为它 - expect(["utf-8", "windows-1252", "iso-8859-1", "shift_jis", "ascii"]).toContain(encoding); + expect(encoding).toBe("windows-1252"); + }); + + it("should handle Windows-1252 encoded data (2)", () => { + // Windows-1252 string: "Price: 10€ – “special” ƒ offer…" + const win1252Data = new Uint8Array([ + // "Price: " + 0x50, 0x72, 0x69, 0x63, 0x65, 0x3a, 0x20, + // "10€ – " + 0x31, 0x30, 0x80, 0x20, 0x96, 0x20, + // “special” + 0x93, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x94, + // " ƒ offer…" + 0x20, 0x83, 0x20, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x85, + ]); + const encoding = detectEncoding(win1252Data, null); + expect(encoding).toBe("windows-1252"); }); it("should fallback to utf-8 when chardet detects invalid encoding", () => { @@ -133,10 +476,34 @@ describe("encoding detection", () => { const encoding = detectEncoding(data, null); // 应该成功返回一个有效的编码 - expect(encoding).toBeTruthy(); + expect(["utf-8", "ascii", "windows-1252"]).toContain(encoding); expect(() => new TextDecoder(encoding)).not.toThrow(); consoleWarnSpy.mockRestore(); }); }); + + describe("real script", () => { + it("script 1", () => { + const textBase64 = [ + "// ==UserScript==
// @name 网页抖音体验增强
// @namespace Violentmonkey Scripts
// @match https://www.douyin.com/?*
// @match *://*.douyin.com/*
// @match *://*.iesdouyin.com/*
// @exclude *://lf-zt.douyin.com*
// @grant none
// @version 3.4
// @changelog 优化文档描述，调整跨域配置指引
// @description 自动跳过直播、智能屏蔽关键字（自动不感兴趣）、跳过广告、最高分辨率、分辨率筛选、AI智能筛选（自动点赞）、极速模式
// @author Frequenk
// @license GPL-3.0 License
// @run-at document-start
// @downloadURL https://update.greasyfork.org/scripts/539942/%E7%BD%91%E9%A1%B5%E6%8A%96%E9%9F%B3%E4%BD%93%E9%AA%8C%E5%A2%9E%E5%BC%BA.user.js
// @updateURL https://update.greasyfork.org/scripts/539942/%E7%BD%91%E9%A1%B5%E6%8A%96%E9%9F%B3%E4%BD%93%E9%AA%8C%E5%A2%9E%E5%BC%BA.meta.js
// ==/UserScript==

(function () {
    'use strict';

    function isElementInViewport(el, text = "") {
        if (!el) return false;
        const rect = el.getBoundingClientRect();
        return (
            rect.width > 0 &&
            rect.height > 0 &&
            rect.bottom > 0 &&
            rect.right > 0 &&
            rect.top < window.innerHeight &&
            rect.left < window.innerWidth
        );
    }

    function getBestVisibleElement(elements) {
        if (!elements || elements.length === 0) {
            return null;
        }

        const visibleElements = Array.from(elements).filter(isElementInViewport);

        if (visibleElements.length === 0) {
            return null;
        }

        if (visibleElements.length === 1) {
            return visibleElements[0];
        }

        let bestCandidate = null;
        let minDistance = Infinity;

        for (const el of visibleElements) {
            const rect = el.getBoundingClientRect();
            const distance = Math.abs(rect.top);
            if (distance < minDistance) {
                minDistance = distance;
                bestCandidate = el;
            }
        }
        return bestCandidate;
    }

    // ========== 通知管理器 ==========
    class NotificationManager {
        constructor() {
            this.container = null;
        }

        createContainer() {
            if (this.container && document.body.contains(this.container)) return;
            this.container = document.createElement('div');
            Object.assign(this.container.style, {
                position: 'fixed',
                top: '100px',
                left: '50%',
                transform: 'translateX(-50%)',
                zIndex: '10001',
                display: 'flex',
                flexDirection: 'column',
                alignItems: 'center',
                gap: '10px'
            });
            document.body.appendChild(this.container);
        }

        showMessage(message, duration = 2000) {
            this.createContainer();

            const messageElement = document.createElement('div');
            messageElement.textContent = message;
            Object.assign(messageElement.style, {
                background: 'rgba(0, 0, 0, 0.8)',
                color: 'white',
                padding: '10px 20px',
                borderRadius: '6px',
                fontSize: '14px',
                boxShadow: '0 2px 8px rgba(0, 0, 0, 0.15)',
                opacity: '0',
                transition: 'opacity 0.3s ease-in-out, transform 0.3s ease-in-out',
                transform: 'translateY(-20px)'
            });

            this.container.appendChild(messageElement);

            // Animate in
            setTimeout(() => {
                messageElement.style.opacity = '1';
                messageElement.style.transform = 'translateY(0)';
            }, 10);

            // Animate out and remove
            setTimeout(() => {
                messageElement.style.opacity = '0';
                messageElement.style.transform = 'translateY(-20px)';
                setTimeout(() => {
                    if (messageElement.parentElement) {
                        messageElement.remove();
                    }
                    if (this.container && this.container.childElementCount === 0) {
                        this.container.remove();
                        this.container = null;
                    }
                }, 300);
            }, duration);
        }
    }

    // ========== 配置管理模块 ==========
    class ConfigManager {
        constructor() {
            this.config = {
                skipLive: { enabled: true, key: 'skipLive' },
                autoHighRes: { enabled: true, key: 'autoHighRes' },
                blockKeywords: {
                    enabled: true,
                    key: 'blockKeywords',
                    keywords: this.loadKeywords(),
                    pressR: this.loadPressRSetting(),
                    blockName: this.loadBlockNameSetting(),
                    blockDesc: this.loadBlockDescSetting(),
                    blockTags: this.loadBlockTagsSetting()
                },
                skipAd: { enabled: true, key: 'skipAd' },
                onlyResolution: {
                    enabled: false,
                    key: 'onlyResolution',
                    resolution: this.loadTargetResolution()
                },
                aiPreference: {
                    enabled: false,
                    key: 'aiPreference',
                    content: this.loadAiContent(),
                    model: this.loadAiModel(),
                    autoLike: this.loadAutoLikeSetting()
                },
                speedMode: {
                    enabled: false,
                    key: 'speedMode',
                    seconds: this.loadSpeedSeconds(),
                    mode: this.loadSpeedModeType(),
                    minSeconds: this.loadSpeedMinSeconds(),
                    maxSeconds: this.loadSpeedMaxSeconds()
                }
            };
        }

        loadKeywords() {
            return JSON.parse(localStorage.getItem('douyin_blocked_keywords') || '["店", "甄选"]');
        }

        loadSpeedSeconds() {
            const v", + "alue = parseInt(localStorage.getItem('douyin_speed_mode_seconds') || '6', 10);
            return Number.isFinite(value) ? Math.min(Math.max(value, 1), 3600) : 6;
        }

        loadSpeedModeType() {
            const mode = localStorage.getItem('douyin_speed_mode_type') || 'fixed';
            return mode === 'random' ? 'random' : 'fixed';
        }

        loadSpeedMinSeconds() {
            const value = parseInt(localStorage.getItem('douyin_speed_mode_min_seconds') || '5', 10);
            return Number.isFinite(value) ? Math.min(Math.max(value, 1), 3600) : 5;
        }

        loadSpeedMaxSeconds() {
            const value = parseInt(localStorage.getItem('douyin_speed_mode_max_seconds') || '10', 10);
            return Number.isFinite(value) ? Math.min(Math.max(value, 1), 3600) : 10;
        }

        loadAiContent() {
            return localStorage.getItem('douyin_ai_content') || '露脸的美女';
        }

        loadAiModel() {
            return localStorage.getItem('douyin_ai_model') || 'qwen3-vl:8b';
        }

        loadTargetResolution() {
            return localStorage.getItem('douyin_target_resolution') || '4K';
        }

        loadPressRSetting() {
            return localStorage.getItem('douyin_press_r_enabled') !== 'false'; // 默认开启
        }

        loadAutoLikeSetting() {
            return localStorage.getItem('douyin_auto_like_enabled') !== 'false'; // 默认开启
        }

        loadBlockNameSetting() {
            return localStorage.getItem('douyin_block_name_enabled') !== 'false'; // 默认开启
        }

        loadBlockDescSetting() {
            return localStorage.getItem('douyin_block_desc_enabled') !== 'false'; // 默认开启
        }

        loadBlockTagsSetting() {
            return localStorage.getItem('douyin_block_tags_enabled') !== 'false'; // 默认开启
        }

        saveKeywords(keywords) {
            this.config.blockKeywords.keywords = keywords;
            localStorage.setItem('douyin_blocked_keywords', JSON.stringify(keywords));
        }

        saveSpeedSeconds(seconds) {
            this.config.speedMode.seconds = seconds;
            localStorage.setItem('douyin_speed_mode_seconds', seconds.toString());
        }

        saveSpeedModeType(mode) {
            this.config.speedMode.mode = mode;
            localStorage.setItem('douyin_speed_mode_type', mode);
        }

        saveSpeedModeRange(minSeconds, maxSeconds) {
            this.config.speedMode.minSeconds = minSeconds;
            this.config.speedMode.maxSeconds = maxSeconds;
            localStorage.setItem('douyin_speed_mode_min_seconds', minSeconds.toString());
            localStorage.setItem('douyin_speed_mode_max_seconds', maxSeconds.toString());
        }

        saveAiContent(content) {
            this.config.aiPreference.content = content;
            localStorage.setItem('douyin_ai_content', content);
        }

        saveAiModel(model) {
            this.config.aiPreference.model = model;
            localStorage.setItem('douyin_ai_model', model);
        }

        saveTargetResolution(resolution) {
            this.config.onlyResolution.resolution = resolution;
            localStorage.setItem('douyin_target_resolution', resolution);
        }

        savePressRSetting(enabled) {
            this.config.blockKeywords.pressR = enabled;
            localStorage.setItem('douyin_press_r_enabled', enabled.toString());
        }

        saveAutoLikeSetting(enabled) {
            this.config.aiPreference.autoLike = enabled;
            localStorage.setItem('douyin_auto_like_enabled', enabled.toString());
        }

        saveBlockNameSetting(enabled) {
            this.config.blockKeywords.blockName = enabled;
            localStorage.setItem('douyin_block_name_enabled', enabled.toString());
        }

        saveBlockDescSetting(enabled) {
            this.config.blockKeywords.blockDesc = enabled;
            localStorage.setItem('douyin_block_desc_enabled', enabled.toString());
        }

        saveBlockTagsSetting(enabled) {
            this.config.blockKeywords.blockTags = enabled;
            localStorage.setItem('douyin_block_tags_enabled', enabled.toString());
        }

        get(key) {
            return this.config[key];
        }

        setEnabled(key, value) {
            if (this.config[key]) {
                this.config[key].enabled = value;
            }
        }

        isEnabled(key) {
            return this.config[key]?.enabled || false;
        }
    }

    // ========== DOM选择器常量 ==========
    const SELECTORS = {
        activeVideo: "[data-e2e='feed-active-video']:has(video[src])",
        resolutionOptions: ".xgplayer-playing div.virtual > div.item",
        accountName: '[data-e2e="feed-video-nickname"]',
        settingsPanel: 'xg-icon.xgplayer-autoplay-setting',
        adIndicator: 'svg[viewBox="0 0 30 16"]',
        videoElement: 'video[src]',
        videoDesc: '[data-e2e="video-desc"]'
    };

    // ========== 视频控制器 ==========
    class VideoController {
        constructor(notificationManager) {
            this.skipCheckInterval = null;
            this.skipAttemptCount = 0;
            this.notificationManager = notificationManager;
        }

        skip(reason) {
            const tip = `跳过视频，原因：${reason}`;
            if (reason) {
                this.notificationManager.showMessage(tip);
            }
            console.log(tip);
            if (!document.body) return;

            const videoBefore = this.getCurrentVideoUrl();
            this.sendKeyEvent('ArrowDown');

            this.clearSkipCheck();
            this.startSkipCheck(videoBefore);
        }

        like() {
            this.notificationManager.showMessage('AI喜好: ❤️ 自动点赞');
            this.sendKeyEvent('z', 'KeyZ', 90);
        }

        pressR() {
            this.notificationManager.showMessage('屏蔽账号: 🚫 不感兴趣');
            this.sendKeyEvent('r', 'KeyR', 82);
        }

        sendKeyEvent(key, code = null, keyCode = null) {
            try {
                const eve", + "nt = new KeyboardEvent('keydown', {
                    key: key,
                    code: code || (key === 'ArrowDown' ? 'ArrowDown' : code),
                    keyCode: keyCode || (key === 'ArrowDown' ? 40 : keyCode),
                    which: keyCode || (key === 'ArrowDown' ? 40 : keyCode),
                    bubbles: true,
                    cancelable: true
                });
                document.body.dispatchEvent(event);
            } catch (error) {
                console.log('发送键盘事件失败:', error);
            }
        }

        getCurrentVideoUrl() {
            const activeContainers = document.querySelectorAll(SELECTORS.activeVideo);
            const lastActiveContainer = getBestVisibleElement(activeContainers);
            if (!lastActiveContainer) return '';
            const videoEl = lastActiveContainer.querySelector(SELECTORS.videoElement);
            return videoEl?.src || '';
        }

        clearSkipCheck() {
            if (this.skipCheckInterval) {
                clearInterval(this.skipCheckInterval);
                this.skipCheckInterval = null;
            }
            this.skipAttemptCount = 0;
        }

        startSkipCheck(urlBefore) {
            this.skipCheckInterval = setInterval(() => {
                if (this.skipAttemptCount >= 5) {
                    this.notificationManager.showMessage('⚠️ 跳过失败，请手动操作');
                    this.clearSkipCheck();
                    return;
                }

                this.skipAttemptCount++;
                const urlAfter = this.getCurrentVideoUrl();
                if (urlAfter && urlAfter !== urlBefore) {
                    console.log('视频已成功切换');
                    this.clearSkipCheck();
                    return;
                }

                const attemptMessage = `跳过失败，正在重试 (${this.skipAttemptCount}/5)`;
                this.notificationManager.showMessage(attemptMessage, 1000);
                console.log(attemptMessage);
                this.sendKeyEvent('ArrowDown');
            }, 500);
        }
    }

    // ========== UI组件工厂 ==========
    class UIFactory {
        static createDialog(className, title, content, onSave, onCancel) {
            const existingDialog = document.querySelector(`.${className}`);
            if (existingDialog) {
                existingDialog.remove();
                return;
            }

            const dialog = document.createElement('div');
            dialog.className = className;
            Object.assign(dialog.style, {
                position: 'fixed',
                top: '50%',
                left: '50%',
                transform: 'translate(-50%, -50%)',
                background: 'rgba(0, 0, 0, 0.9)',
                border: '1px solid rgba(255, 255, 255, 0.2)',
                borderRadius: '8px',
                padding: '20px',
                zIndex: '10000',
                minWidth: '250px'
            });

            dialog.innerHTML = `
                <div style="color: white; margin-bottom: 15px; font-size: 14px;">${title}</div>
                ${content}
                <div style="display: flex; gap: 10px; margin-top: 15px;">
                    <button class="dialog-confirm" style="flex: 1; padding: 5px; background: #fe2c55;
                            color: white; border: none; border-radius: 4px; cursor: pointer;">确定</button>
                    <button class="dialog-cancel" style="flex: 1; padding: 5px; background: rgba(255, 255, 255, 0.1);
                            color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px; cursor: pointer;">取消</button>
                </div>
            `;

            document.body.appendChild(dialog);

            dialog.querySelector('.dialog-confirm').addEventListener('click', () => {
                if (onSave()) dialog.remove();
            });

            dialog.querySelector('.dialog-cancel').addEventListener('click', () => {
                dialog.remove();
                if (onCancel) onCancel();
            });

            setTimeout(() => {
                document.addEventListener('click', function closeDialog(e) {
                    if (!dialog.contains(e.target)) {
                        dialog.remove();
                        document.removeEventListener('click', closeDialog);
                    }
                });
            }, 100);

            return dialog;
        }

        static createToggleButton(text, className, isEnabled, onToggle, onClick = null, shortcut = null) {
            const btnContainer = document.createElement('xg-icon');
            btnContainer.className = `xgplayer-autoplay-setting ${className}`;

            const shortcutHint = shortcut
                ? `<div class="xgTips"><span>${text.replace(/<[^>]*>/g, '')}</span><span class="shortcutKey">${shortcut}</span></div>`
                : '';

            btnContainer.innerHTML = `
                <div class="xgplayer-icon">
                    <div class="xgplayer-setting-label">
                        <button aria-checked="${isEnabled}" class="xg-switch ${isEnabled ? 'xg-switch-checked' : ''}">
                            <span class="xg-switch-inner"></span>
                        </button>
                        <span class="xgplayer-setting-title" style="${onClick ? 'cursor: pointer; text-decoration: underline;' : ''}">${text}</span>
                    </div>
                </div>${shortcutHint}`;

            btnContainer.querySelector('button').addEventListener('click', (e) => {
                const newState = e.currentTarget.getAttribute('aria-checked') === 'false';
                UIManager.updateToggleButtons(className, newState);
                onToggle(newState);
            });

            if (onClick) {
                btnContainer.querySelector('.xgplayer-setting-title').addEventListener('click', (e) => {
                    e.stopPropagation();
                    onClick();
                });
            }

            return btnContainer;
        }

        static showErrorDialo", + "g() {
            const dialog = document.createElement('div');
            dialog.className = 'error-dialog-' + Date.now();
            dialog.style.cssText = `
                position: fixed;
                top: 50%;
                left: 50%;
                transform: translate(-50%, -50%);
                background: rgba(0, 0, 0, 0.95);
                border: 2px solid rgba(254, 44, 85, 0.8);
                color: white;
                padding: 25px;
                border-radius: 12px;
                z-index: 10001;
                max-width: 500px;
                max-height: 80vh;
                overflow-y: auto;
                text-align: left;
                font-size: 14px;
                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
            `;

            const commonStyle = `background: rgba(255, 255, 255, 0.1); padding: 8px; border-radius: 4px; font-family: monospace; margin: 5px 0; display: block; user-select: text;`;
            const h3Style = `color: #fe2c55; margin: 15px 0 8px 0; font-size: 15px; border-bottom: 1px solid rgba(255,255,255,0.1); padding-bottom: 5px;`;

            dialog.innerHTML = `
                <div style="text-align: center; margin-bottom: 20px;">
                    <div style="font-size: 32px; margin-bottom: 10px;">⚠️ 连接失败</div>
                    <p style="color: #aaa; font-size: 13px;">请确保 <a href="https://ollama.com/" target="_blank" style="color: #fe2c55;">Ollama</a> 已运行并配置跨域访问</p>
                </div>

                <div style="background: rgba(0,0,0,0.3); padding: 15px; border-radius: 8px; margin-bottom: 20px;">
                    <h3 style="${h3Style}">🖥️ Windows 配置</h3>
                    <ol style="padding-left: 20px; margin: 0; line-height: 1.6;">
                        <li>打开 <strong>控制面板</strong> -> 系统 -> 高级系统设置 -> 环境变量</li>
                        <li>在 <strong>用户变量</strong> 点击新建，添加两个变量：
                            <div style="${commonStyle}">
                                OLLAMA_HOST = 0.0.0.0<br>
                                OLLAMA_ORIGINS = *
                            </div>
                        </li>
                        <li>点击确定保存，重启 Ollama</li>
                    </ol>

                    <h3 style="${h3Style}">🍎 macOS 配置</h3>
                    <div style="margin-bottom: 5px;">打开终端运行以下命令，然后重启 Ollama：</div>
                    <code style="${commonStyle}">
                        launchctl setenv OLLAMA_HOST "0.0.0.0"<br>
                        launchctl setenv OLLAMA_ORIGINS "*"
                    </code>

                    <h3 style="${h3Style}">🐧 Linux (systemd) 配置</h3>
                    <div style="margin-bottom: 5px;">1. 编辑服务配置: <code style="background:rgba(255,255,255,0.1); px-1">sudo systemctl edit ollama.service</code></div>
                    <div style="margin-bottom: 5px;">2. 在 <code style="color:#aaa">[Service]</code> 下方添加：</div>
                    <code style="${commonStyle}">
                        [Service]<br>
                        Environment="OLLAMA_HOST=0.0.0.0"<br>
                        Environment="OLLAMA_ORIGINS=*"
                    </code>
                    <div style="margin-top: 5px;">3. 重启服务: <code style="background:rgba(255,255,255,0.1); px-1">sudo systemctl daemon-reload && sudo systemctl restart ollama</code></div>
                </div>

                <div style="text-align: center;">
                    <div class="error-dialog-close" style="margin-top: 10px; font-size: 14px; color: #fe2c55; cursor: pointer; text-decoration: underline;">关闭</div>
                </div>
            `;

            document.body.appendChild(dialog);

            // 点击关闭文字
            dialog.querySelector('.error-dialog-close').addEventListener('click', () => {
                dialog.remove();
            });

            // 点击背景关闭
            dialog.addEventListener('click', (e) => {
                if (e.target === dialog) dialog.remove();
            });
        }
    }

    // ========== UI管理器 ==========
    class UIManager {
        constructor(config, videoController, notificationManager) {
            this.config = config;
            this.videoController = videoController;
            this.notificationManager = notificationManager;
            this.initButtons();
        }

        initButtons() {
            this.buttonConfigs = [
                {
                    text: '跳直播',
                    className: 'skip-live-button',
                    configKey: 'skipLive',
                    shortcut: '='
                },
                {
                    text: '跳广告',
                    className: 'skip-ad-button',
                    configKey: 'skipAd'
                },
                {
                    text: '账号屏蔽',
                    className: 'block-account-keyword-button',
                    configKey: 'blockKeywords',
                    onClick: () => this.showKeywordDialog()
                },
                {
                    text: '最高清',
                    className: 'auto-high-resolution-button',
                    configKey: 'autoHighRes'
                },
                {
                    text: `${this.config.get('onlyResolution').resolution}筛选`,
                    className: 'resolution-filter-button',
                    configKey: 'onlyResolution',
                    onClick: () => this.showResolutionDialog()
                },
                {
                    text: 'AI喜好',
                    className: 'ai-preference-button',
                    configKey: 'aiPreference',
                    onClick: () => this.showAiPreferenceDialog()
                },
                {
                    text: this.getSpeedModeLabel(),
                    className: '", + "speed-mode-button',
                    configKey: 'speedMode',
                    onClick: () => this.showSpeedDialog()
                }
            ];
        }

        insertButtons() {
            document.querySelectorAll(SELECTORS.settingsPanel).forEach(panel => {
                const parent = panel.parentNode;
                if (!parent) return;

                let lastButton = panel;
                this.buttonConfigs.forEach(config => {
                    let button = parent.querySelector(`.${config.className}`);
                    if (!button) {
                        button = UIFactory.createToggleButton(
                            config.text,
                            config.className,
                            this.config.isEnabled(config.configKey),
                            (state) => {
                                this.config.setEnabled(config.configKey, state);
                                if (config.configKey === 'skipLive') {
                                    this.notificationManager.showMessage(`功能开关: 跳过直播已 ${state ? '✅' : '❌'}`);
                                } else if (config.configKey === 'speedMode') {
                                    document.dispatchEvent(new CustomEvent('douyin-speed-mode-updated'));
                                }
                            },
                            config.onClick,
                            config.shortcut
                        );
                        parent.insertBefore(button, lastButton.nextSibling);
                    }
                    const isEnabled = this.config.isEnabled(config.configKey);
                    const switchEl = button.querySelector('.xg-switch');
                    if (switchEl) {
                        switchEl.classList.toggle('xg-switch-checked', isEnabled);
                        switchEl.setAttribute('aria-checked', String(isEnabled));
                    }
                    const titleEl = button.querySelector('.xgplayer-setting-title');
                    if (titleEl && typeof config.text === 'string') {
                        titleEl.textContent = config.text;
                    }
                    lastButton = button;
                });
            });
        }

        static updateToggleButtons(className, isEnabled) {
            document.querySelectorAll(`.${className} .xg-switch`).forEach(sw => {
                sw.classList.toggle('xg-switch-checked', isEnabled);
                sw.setAttribute('aria-checked', String(isEnabled));
            });
        }

        updateSpeedModeText() {
            const label = this.getSpeedModeLabel();
            const speedButtonConfig = this.buttonConfigs?.find(config => config.configKey === 'speedMode');
            if (speedButtonConfig) {
                speedButtonConfig.text = label;
            }
            document.querySelectorAll('.speed-mode-button .xgplayer-setting-title').forEach(el => {
                el.textContent = label;
            });
        }

        getSpeedModeLabel() {
            const speedConfig = this.config.get('speedMode');
            console.log('speedConfig', speedConfig)
            if (speedConfig.mode === 'random') {
                return `随机${speedConfig.minSeconds}-${speedConfig.maxSeconds}秒`;
            }
            return `${speedConfig.seconds}秒切`;
        }

        updateResolutionText() {
            const resolution = this.config.get('onlyResolution').resolution;
            const resolutionButtonConfig = this.buttonConfigs?.find(config => config.configKey === 'onlyResolution');
            if (resolutionButtonConfig) {
                resolutionButtonConfig.text = `${resolution}筛选`;
            }
            document.querySelectorAll('.resolution-filter-button .xgplayer-setting-title').forEach(el => {
                el.textContent = `${resolution}筛选`;
            });
        }

        showSpeedDialog() {
            const speedConfig = this.config.get('speedMode');
            const isRandom = speedConfig.mode === 'random';
            const content = `
                <div style="margin-bottom: 15px; color: rgba(255, 255, 255, 0.8); font-size: 13px;">
                    <label style="display: flex; align-items: center; margin-bottom: 8px; cursor: pointer;">
                        <input type="radio" name="speed-mode-type" value="fixed" ${isRandom ? '' : 'checked'}
                               style="margin-right: 8px;">
                        固定时间模式
                    </label>
                    <label style="display: flex; align-items: center; cursor: pointer;">
                        <input type="radio" name="speed-mode-type" value="random" ${isRandom ? 'checked' : ''}
                               style="margin-right: 8px;">
                        随机时间模式
                    </label>
                </div>
                <div class="speed-fixed-wrapper" style="display: ${isRandom ? 'none' : 'block'};">
                    <input type="number" class="speed-input" min="1" max="3600" value="${speedConfig.seconds}"
                        style="width: 100%; padding: 8px; background: rgba(255, 255, 255, 0.1);
                               color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;">
                </div>
                <div class="speed-random-wrapper" style="display: ${isRandom ? 'flex' : 'none'}; gap: 10px; align-items: center;">
                    <input type="number" class="speed-min-input" min="1" max="3600" value="${speedConfig.minSeconds}"
                        style="flex: 1; padding: 8px; background: rgba(255, 255, 255, 0.1); color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;">
                    <span style="color: rgba(255, 255, 255, 0.6);">—</span>
                    <input type="number" class="speed-max-input" min="1" max="3600" value="${speedConfig.maxSeconds}"
                        style="flex: 1; padding: 8px; background: rgba(255, 255, 255, 0.1); color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius", + ": 4px;">
                </div>
                <div style="color: rgba(255, 255, 255, 0.5); font-size: 11px; margin-top: 12px;">
                    范围需在 1-3600 秒之间，随机模式将在区间内为每个视频生成一个等待时间
                </div>
            `;

            const dialog = UIFactory.createDialog('speed-mode-time-dialog', '设置极速模式', content, () => {
                const modeInput = dialog.querySelector('input[name="speed-mode-type"]:checked');
                const mode = modeInput ? modeInput.value : 'fixed';

                if (mode === 'fixed') {
                    const input = dialog.querySelector('.speed-input');
                    const value = parseInt(input.value, 10);
                    if (!Number.isFinite(value) || value < 1 || value > 3600) {
                        alert('请输入 1 - 3600 秒之间的整数');
                        return false;
                    }
                    this.config.saveSpeedModeType('fixed');
                    this.config.saveSpeedSeconds(value);
                    this.notificationManager.showMessage(`⚙️ 极速模式: 播放时间已设为 ${value} 秒`);
                } else {
                    const minInput = dialog.querySelector('.speed-min-input');
                    const maxInput = dialog.querySelector('.speed-max-input');
                    const minValue = parseInt(minInput.value, 10);
                    const maxValue = parseInt(maxInput.value, 10);
                    if (!Number.isFinite(minValue) || minValue < 1 || minValue > 3600 ||
                        !Number.isFinite(maxValue) || maxValue < 1 || maxValue > 3600) {
                        alert('随机范围需在 1 - 3600 秒之间');
                        return false;
                    }
                    if (minValue > maxValue) {
                        alert('最小时间不能大于最大时间');
                        return false;
                    }
                    this.config.saveSpeedModeType('random');
                    this.config.saveSpeedModeRange(minValue, maxValue);
                    this.notificationManager.showMessage(`⚙️ 极速模式: 已设为随机 ${minValue}-${maxValue} 秒`);
                }

                this.updateSpeedModeText();
                document.dispatchEvent(new CustomEvent('douyin-speed-mode-updated'));
                return true;
            });

            if (!dialog) return;

            const toggleVisibility = () => {
                const modeInput = dialog.querySelector('input[name="speed-mode-type"]:checked');
                const isRandomMode = modeInput && modeInput.value === 'random';
                dialog.querySelector('.speed-fixed-wrapper').style.display = isRandomMode ? 'none' : 'block';
                dialog.querySelector('.speed-random-wrapper').style.display = isRandomMode ? 'flex' : 'none';
            };

            dialog.querySelectorAll('input[name="speed-mode-type"]').forEach(radio => {
                radio.addEventListener('change', toggleVisibility);
            });
        }

        showAiPreferenceDialog() {
            const currentContent = this.config.get('aiPreference').content;
            const currentModel = this.config.get('aiPreference').model;
            const autoLikeEnabled = this.config.get('aiPreference').autoLike;

            const content = `
                <div style="margin-bottom: 15px;">
                    <label style="color: rgba(255, 255, 255, 0.7); font-size: 12px; display: block; margin-bottom: 5px;">
                        想看什么内容？（例如：露脸的美女、猫咪）
                    </label>
                    <input type="text" class="ai-content-input" value="${currentContent}" placeholder="输入你想看的内容"
                        style="width: 100%; padding: 8px; background: rgba(255, 255, 255, 0.1);
                               color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;">
                </div>

                <div style="margin-bottom: 15px;">
                    <label style="color: rgba(255, 255, 255, 0.7); font-size: 12px; display: block; margin-bottom: 5px;">
                        AI模型选择
                    </label>
                    <div style="position: relative;">
                        <select class="ai-model-select"
                            style="width: 100%; padding: 8px; background: rgba(255, 255, 255, 0.1);
                                   color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;
                                   appearance: none; cursor: pointer;">
                            <option value="qwen3-vl:8b" style="background: rgba(0, 0, 0, 0.9); color: white;" ${currentModel === 'qwen3-vl:8b' ? 'selected' : ''}>qwen3-vl:8b (推荐)</option>
                            <option value="qwen2.5vl:7b" style="background: rgba(0, 0, 0, 0.9); color: white;" ${currentModel === 'qwen2.5vl:7b' ? 'selected' : ''}>qwen2.5vl:7b</option>
                            <option value="custom" style="background: rgba(0, 0, 0, 0.9); color: white;" ${currentModel !== 'qwen3-vl:8b' && currentModel !== 'qwen2.5vl:7b' ? 'selected' : ''}>自定义模型</option>
                        </select>
                        <span style="position: absolute; right: 10px; top: 50%; transform: translateY(-50%);
                                   pointer-events: none; color: rgba(255, 255, 255, 0.5);">▼</span>
                    </div>
                    <input type="text" class="ai-model-input" value="${currentModel !== 'qwen3-vl:8b' && currentModel !== 'qwen2.5vl:7b' ? currentModel : ''}"
                        placeholder="输入自定义模型名称"
                        style="width: 100%; padding: 8px; margin-top: 10px; background: rgba(255, 255, 255, 0.1);
                               color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;
                               display: ${currentModel !== 'qwen3-vl:8b' && currentModel !== 'qwen2.5vl:7b' ? 'block' : 'none'};">
 ", + "               </div>

                <div style="margin-bottom: 15px; padding: 10px; background: rgba(255, 255, 255, 0.05); border-radius: 6px;">
                    <label style="display: flex; align-items: center; cursor: pointer; color: white; font-size: 13px;">
                        <input type="checkbox" class="auto-like-checkbox" ${autoLikeEnabled ? 'checked' : ''}
                               style="margin-right: 8px; transform: scale(1.2);">
                        AI判定为喜欢的内容将自动点赞（Z键）
                    </label>
                    <div style="color: rgba(255, 255, 255, 0.5); font-size: 11px; margin-top: 5px; margin-left: 24px;">
                        帮助抖音算法了解你喜欢此类内容
                    </div>
                </div>

                <div style="color: rgba(255, 255, 255, 0.5); font-size: 11px; margin-bottom: 10px;">
                    提示：需要安装 <a href="https://ollama.com/" target="_blank" style="color: #fe2c55;">Ollama</a> 并下载视觉模型
                </div>
            `;

            const dialog = UIFactory.createDialog('ai-preference-dialog', '设置AI喜好', content, () => {
                const contentInput = dialog.querySelector('.ai-content-input');
                const modelSelect = dialog.querySelector('.ai-model-select');
                const modelInput = dialog.querySelector('.ai-model-input');
                const autoLikeCheckbox = dialog.querySelector('.auto-like-checkbox');

                const content = contentInput.value.trim();
                let model = modelSelect.value === 'custom'
                    ? modelInput.value.trim()
                    : modelSelect.value;

                if (!content) {
                    alert('请输入想看的内容');
                    return false;
                }

                if (!model) {
                    alert('请选择或输入模型名称');
                    return false;
                }

                this.config.saveAiContent(content);
                this.config.saveAiModel(model);
                this.config.saveAutoLikeSetting(autoLikeCheckbox.checked);

                this.notificationManager.showMessage('🤖 AI喜好: 设置已保存');
                return true;
            });

            // 处理模型选择切换
            const modelSelect = dialog.querySelector('.ai-model-select');
            const modelInput = dialog.querySelector('.ai-model-input');

            modelSelect.addEventListener('change', (e) => {
                if (e.target.value === 'custom') {
                    modelInput.style.display = 'block';
                } else {
                    modelInput.style.display = 'none';
                    modelInput.value = '';
                }
            });

            // 防止复选框点击时关闭弹窗
            dialog.querySelector('.auto-like-checkbox').addEventListener('click', (e) => {
                e.stopPropagation();
            });
        }

        showKeywordDialog() {
            const keywords = this.config.get('blockKeywords').keywords;
            let tempKeywords = [...keywords];

            const updateList = () => {
                const container = document.querySelector('.keyword-list');
                if (!container) return;

                container.innerHTML = tempKeywords.length === 0
                    ? '<div style="color: rgba(255, 255, 255, 0.5); text-align: center;">暂无关键字</div>'
                    : tempKeywords.map((keyword, index) => `
                        <div style="display: flex; align-items: center; margin-bottom: 8px;">
                            <span style="flex: 1; color: white; padding: 5px 10px; background: rgba(255, 255, 255, 0.1);
                                   border-radius: 4px; margin-right: 10px;">${keyword}</span>
                            <button data-index="${index}" class="delete-keyword" style="padding: 5px 10px; background: #ff4757;
                                    color: white; border: none; border-radius: 4px; cursor: pointer;">删除</button>
                        </div>
                    `).join('');

                // 使用事件委托来处理删除按钮点击
                container.onclick = (e) => {
                    if (e.target.classList.contains('delete-keyword')) {
                        e.stopPropagation(); // 阻止事件冒泡，防止触发弹窗关闭
                        const index = parseInt(e.target.dataset.index);
                        tempKeywords.splice(index, 1);
                        updateList();
                    }
                };
            };

            const pressREnabled = this.config.get('blockKeywords').pressR;
            const blockNameEnabled = this.config.get('blockKeywords').blockName;
            const blockDescEnabled = this.config.get('blockKeywords').blockDesc;
            const blockTagsEnabled = this.config.get('blockKeywords').blockTags;

            const content = `
                <div style="color: rgba(255, 255, 255, 0.7); margin-bottom: 15px; font-size: 12px;">
                    包含这些关键字的内容将被自动跳过
                </div>

                <div style="margin-bottom: 15px; padding: 10px; background: rgba(255, 255, 255, 0.05); border-radius: 6px;">
                    <label style="display: flex; align-items: center; cursor: pointer; color: white; font-size: 13px;">
                        <input type="checkbox" class="press-r-checkbox" ${pressREnabled ? 'checked' : ''}
                               style="margin-right: 8px; transform: scale(1.2);">
                        跳过时自动按R键（不感兴趣）
                    </label>
                    <div style="color: rgba(255, 255, 255, 0.5); font-size: 11px; margin-top: 5px; margin-left: 24px;">
                        勾选：告诉抖音你不喜欢，优化推荐算法<br>
                        不勾：仅跳到下一个视频
                    </div>
                </div>

                <div style="margin-bottom: 15px; padding: 10px", + "; background: rgba(255, 255, 255, 0.05); border-radius: 6px;">
                    <div style="color: rgba(255, 255, 255, 0.7); font-size: 12px; margin-bottom: 8px;">检测范围：</div>
                    <label style="display: flex; align-items: center; cursor: pointer; color: white; font-size: 13px; margin-bottom: 6px;">
                        <input type="checkbox" class="block-name-checkbox" ${blockNameEnabled ? 'checked' : ''}
                               style="margin-right: 8px; transform: scale(1.2);">
                        屏蔽名称（账号昵称）
                    </label>
                    <label style="display: flex; align-items: center; cursor: pointer; color: white; font-size: 13px; margin-bottom: 6px;">
                        <input type="checkbox" class="block-desc-checkbox" ${blockDescEnabled ? 'checked' : ''}
                               style="margin-right: 8px; transform: scale(1.2);">
                        屏蔽简介（视频描述文案）
                    </label>
                    <label style="display: flex; align-items: center; cursor: pointer; color: white; font-size: 13px;">
                        <input type="checkbox" class="block-tags-checkbox" ${blockTagsEnabled ? 'checked' : ''}
                               style="margin-right: 8px; transform: scale(1.2);">
                        屏蔽标签（#话题标签）
                    </label>
                </div>

                <div style="display: flex; gap: 10px; margin-bottom: 10px;">
                    <input type="text" class="keyword-input" placeholder="输入新关键字"
                        style="flex: 1; padding: 8px; background: rgba(255, 255, 255, 0.1);
                               color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;">
                    <button class="add-keyword" style="padding: 8px 15px; background: #00d639;
                            color: white; border: none; border-radius: 4px; cursor: pointer;">添加</button>
                </div>

                <div style="display: flex; gap: 10px; margin-bottom: 10px;">
                    <button class="import-keywords" style="flex: 1; padding: 8px 12px; background: rgba(52, 152, 219, 0.8);
                            color: white; border: none; border-radius: 4px; cursor: pointer; font-size: 12px;">
                        📁 导入关键字
                    </button>
                    <button class="export-keywords" style="flex: 1; padding: 8px 12px; background: rgba(155, 89, 182, 0.8);
                            color: white; border: none; border-radius: 4px; cursor: pointer; font-size: 12px;">
                        💾 导出关键字
                    </button>
                </div>
                <div class="keyword-list" style="margin-bottom: 15px; max-height: 200px; overflow-y: auto;"></div>
            `;

            const dialog = UIFactory.createDialog('keyword-setting-dialog', '管理屏蔽关键字', content, () => {
                const pressRCheckbox = dialog.querySelector('.press-r-checkbox');
                const blockNameCheckbox = dialog.querySelector('.block-name-checkbox');
                const blockDescCheckbox = dialog.querySelector('.block-desc-checkbox');
                const blockTagsCheckbox = dialog.querySelector('.block-tags-checkbox');

                this.config.saveKeywords(tempKeywords);
                this.config.savePressRSetting(pressRCheckbox.checked);
                this.config.saveBlockNameSetting(blockNameCheckbox.checked);
                this.config.saveBlockDescSetting(blockDescCheckbox.checked);
                this.config.saveBlockTagsSetting(blockTagsCheckbox.checked);

                this.notificationManager.showMessage('🚫 屏蔽关键字: 设置已更新');
                return true;
            });

            const addKeyword = () => {
                const input = dialog.querySelector('.keyword-input');
                const keyword = input.value.trim();
                if (keyword && !tempKeywords.includes(keyword)) {
                    tempKeywords.push(keyword);
                    updateList();
                    input.value = '';
                }
            };

            dialog.querySelector('.add-keyword').addEventListener('click', (e) => {
                e.stopPropagation(); // 阻止事件冒泡，防止触发弹窗关闭
                addKeyword();
            });
            dialog.querySelector('.keyword-input').addEventListener('keypress', (e) => {
                if (e.key === 'Enter') {
                    e.stopPropagation(); // 阻止事件冒泡
                    addKeyword();
                }
            });

            // 防止在输入框内点击时关闭弹窗
            dialog.querySelector('.keyword-input').addEventListener('click', (e) => {
                e.stopPropagation();
            });

            // 防止复选框点击时关闭弹窗
            dialog.querySelector('.press-r-checkbox').addEventListener('click', (e) => {
                e.stopPropagation();
            });
            dialog.querySelector('.block-name-checkbox').addEventListener('click', (e) => {
                e.stopPropagation();
            });
            dialog.querySelector('.block-desc-checkbox').addEventListener('click', (e) => {
                e.stopPropagation();
            });
            dialog.querySelector('.block-tags-checkbox').addEventListener('click', (e) => {
                e.stopPropagation();
            });

            // 导出功能
            const exportKeywords = () => {
                const content = tempKeywords.join('\n');
                const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `抖音屏蔽关键字_${new Date().toISOString().split('T')[0]}.txt`;
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
        ", + "        URL.revokeObjectURL(url);
                this.notificationManager.showMessage('💾 屏蔽账号: 关键字已导出');
            };

            dialog.querySelector('.export-keywords').addEventListener('click', (e) => {
                e.stopPropagation();
                exportKeywords();
            });

            // 导入功能
            const importKeywords = () => {
                const input = document.createElement('input');
                input.type = 'file';
                input.accept = '.txt';
                input.addEventListener('change', (e) => {
                    const file = e.target.files[0];
                    if (file) {
                        const reader = new FileReader();
                        reader.onload = (e) => {
                            const content = e.target.result;
                            const importedKeywords = content.split('\n')
                                .map(line => line.trim())
                                .filter(line => line.length > 0);

                            if (importedKeywords.length > 0) {
                                // 合并关键字，去重
                                const allKeywords = [...new Set([...tempKeywords, ...importedKeywords])];
                                tempKeywords.splice(0, tempKeywords.length, ...allKeywords);
                                updateList();
                                this.notificationManager.showMessage('📁 屏蔽账号: 关键字导入成功');
                            } else {
                                alert('文件内容为空或格式不正确！');
                            }
                        };
                        reader.onerror = () => {
                            alert('文件读取失败！');
                        };
                        reader.readAsText(file, 'utf-8');
                    }
                });
                input.click();
            };

            dialog.querySelector('.import-keywords').addEventListener('click', (e) => {
                e.stopPropagation();
                importKeywords();
            });

            updateList();
        }

        showResolutionDialog() {
            const currentResolution = this.config.get('onlyResolution').resolution;
            const resolutions = ['4K', '2K', '1080P', '720P', '540P'];

            const content = `
                <div style="margin-bottom: 15px;">
                    <label style="color: rgba(255, 255, 255, 0.7); font-size: 12px; display: block; margin-bottom: 5px;">
                        选择要筛选的分辨率
                    </label>
                    <div style="position: relative;">
                        <select class="resolution-select"
                            style="width: 100%; padding: 8px; background: rgba(255, 255, 255, 0.1);
                                   color: white; border: 1px solid rgba(255, 255, 255, 0.3); border-radius: 4px;
                                   appearance: none; cursor: pointer;">
                            ${resolutions.map(res =>
                `<option value="${res}" style="background: rgba(0, 0, 0, 0.9); color: white;" ${currentResolution === res ? 'selected' : ''}>${res}</option>`
            ).join('')}
                        </select>
                        <span style="position: absolute; right: 10px; top: 50%; transform: translateY(-50%);
                                   pointer-events: none; color: rgba(255, 255, 255, 0.5);">▼</span>
                    </div>
                </div>

                <div style="color: rgba(255, 255, 255, 0.5); font-size: 11px; margin-bottom: 10px;">
                    提示：只播放包含所选分辨率关键字的视频，没有找到则自动跳过
                </div>
            `;

            const dialog = UIFactory.createDialog('resolution-dialog', '分辨率筛选设置', content, () => {
                const resolutionSelect = dialog.querySelector('.resolution-select');
                const resolution = resolutionSelect.value;

                this.config.saveTargetResolution(resolution);
                this.updateResolutionText();
                this.notificationManager.showMessage(`⚙️ 分辨率筛选: 已设为 ${resolution}`);
                return true;
            });
        }
    }

    // ========== AI检测器 ==========
    class AIDetector {
        constructor(videoController, config) {
            this.videoController = videoController;
            this.config = config;
            this.API_URL = 'http://localhost:11434/api/generate';
            this.checkSchedule = [0, 1000, 2500, 4000, 6000, 8000];
            this.reset();
        }

        reset() {
            this.currentCheckIndex = 0;
            this.checkResults = [];
            this.consecutiveYes = 0;
            this.consecutiveNo = 0;
            this.hasSkipped = false;
            this.stopChecking = false;
            this.hasLiked = false;
            this.isProcessing = false;
        }

        shouldCheck(videoPlayTime) {
            return !this.isProcessing &&
                !this.stopChecking &&
                !this.hasSkipped &&
                this.currentCheckIndex < this.checkSchedule.length &&
                videoPlayTime >= this.checkSchedule[this.currentCheckIndex];
        }

        async processVideo(videoEl) {
            if (this.isProcessing || this.stopChecking || this.hasSkipped) return;
            this.isProcessing = true;

            try {
                const base64Image = await this.captureVideoFrame(videoEl);
                const aiResponse = await this.callAI(base64Image);
                this.handleResponse(aiResponse);
                this.currentCheckIndex++;
            } catch (error) {
                console.error('AI判断功能出错:', error);
                // 显示错误提示
                UIFactory.showErrorDialog();
                // 关闭AI喜好模式
                this.config.setEnabled('aiPreference', false);
                UIManager.updateToggleButtons('ai-preference-button', false", + ");
                this.stopChecking = true;
            } finally {
                this.isProcessing = false;
            }
        }

        async captureVideoFrame(videoEl) {
            const canvas = document.createElement('canvas');
            const maxSize = 500;
            const aspectRatio = videoEl.videoWidth / videoEl.videoHeight;

            let targetWidth, targetHeight;
            if (videoEl.videoWidth > videoEl.videoHeight) {
                targetWidth = Math.min(videoEl.videoWidth, maxSize);
                targetHeight = Math.round(targetWidth / aspectRatio);
            } else {
                targetHeight = Math.min(videoEl.videoHeight, maxSize);
                targetWidth = Math.round(targetHeight * aspectRatio);
            }

            canvas.width = targetWidth;
            canvas.height = targetHeight;

            const ctx = canvas.getContext('2d');
            ctx.drawImage(videoEl, 0, 0, targetWidth, targetHeight);

            return canvas.toDataURL('image/jpeg', 0.8).split(',')[1];
        }

        async callAI(base64Image) {
            const content = this.config.get('aiPreference').content;
            const model = this.config.get('aiPreference').model;

            const response = await fetch(this.API_URL, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    model: model,
                    prompt: `这是${content}吗?回答『是』或者『不是』,不要说任何多余的字符`,
                    images: [base64Image],
                    stream: false
                })
            });

            if (!response.ok) {
                throw new Error(`AI请求失败: ${response.status}`);
            }

            const result = await response.json();
            return result.response?.trim();
        }

        handleResponse(aiResponse) {
            const content = this.config.get('aiPreference').content;
            this.checkResults.push(aiResponse);
            console.log(`AI检测结果[${this.checkResults.length}]：${aiResponse}`);

            if (aiResponse === '是') {
                this.consecutiveYes++;
                this.consecutiveNo = 0;
            } else {
                this.consecutiveYes = 0;
                this.consecutiveNo++;
            }

            if (this.consecutiveNo >= 1) {
                this.hasSkipped = true;
                this.stopChecking = true;
                this.videoController.skip(`🤖 AI筛选: 非'${content}'`);
            } else if (this.consecutiveYes >= 2) {
                console.log(`【停止检测】连续2次判定为${content}，安心观看`);
                this.stopChecking = true;

                // 检查是否开启了自动点赞功能
                const autoLikeEnabled = this.config.get('aiPreference').autoLike;
                if (!this.hasLiked && autoLikeEnabled) {
                    this.videoController.like();
                    this.hasLiked = true;
                } else if (!autoLikeEnabled) {
                    console.log('【自动点赞】功能已关闭，跳过点赞');
                }
            }
        }
    }

    // ========== 视频检测策略 ==========
    class VideoDetectionStrategies {
        constructor(config, videoController, notificationManager) {
            this.config = config;
            this.videoController = videoController;
            this.notificationManager = notificationManager;
            this.resolutionSkipped = false;
        }

        reset() {
            this.resolutionSkipped = false;
        }

        checkAd(container) {
            if (!this.config.isEnabled('skipAd')) return false;

            const adIndicator = container.querySelector(SELECTORS.adIndicator);
            if (adIndicator) {
                this.videoController.skip('⏭️ 自动跳过: 广告视频');
                return true;
            }
            return false;
        }

        checkBlockedAccount(container) {
            if (!this.config.isEnabled('blockKeywords')) return false;

            const blockConfig = this.config.get('blockKeywords');
            const keywords = blockConfig.keywords;
            const pressREnabled = blockConfig.pressR;
            const blockName = blockConfig.blockName;
            const blockDesc = blockConfig.blockDesc;
            const blockTags = blockConfig.blockTags;

            // 如果三个检测选项都没开启，直接返回
            if (!blockName && !blockDesc && !blockTags) return false;

            let matchedKeyword = null;
            let matchType = '';

            // 检测名称（账号昵称）
            if (blockName && !matchedKeyword) {
                const accountEl = container.querySelector(SELECTORS.accountName);
                const accountName = accountEl?.textContent.trim();
                if (accountName) {
                    matchedKeyword = keywords.find(kw => accountName.includes(kw));
                    if (matchedKeyword) matchType = '名称';
                }
            }

            // 检测简介（视频描述文案，排除标签）
            if (blockDesc && !matchedKeyword) {
                const descEl = container.querySelector(SELECTORS.videoDesc);
                if (descEl) {
                    // 获取纯文本，然后移除 #xxx 标签
                    const descText = descEl.textContent.replace(/#\S+/g, '').trim();
                    if (descText) {
                        matchedKeyword = keywords.find(kw => descText.includes(kw));
                        if (matchedKeyword) matchType = '简介';
                    }
                }
            }

            // 检测标签（#话题标签）
            if (blockTags && !matchedKeyword) {
                const descEl = container.querySelector(SELECTORS.videoDesc);
                if (descEl) {
                    // 提取所有 #xxx 标签
                    const tags = descEl.textContent.match(/#\S+/g) || [];
                    const tagsText = tags.join(' ');
          ", + "          if (tagsText) {
                        matchedKeyword = keywords.find(kw => tagsText.includes(kw));
                        if (matchedKeyword) matchType = '标签';
                    }
                }
            }

            // 如果匹配到关键字，执行跳过操作
            if (matchedKeyword) {
                if (pressREnabled) {
                    // 如果开启了按R键功能，按R键（视频会直接消失）
                    this.videoController.pressR();
                } else {
                    // 如果没开启R键功能，则使用下键跳过
                    this.videoController.skip(`🚫 屏蔽${matchType}: 关键字"${matchedKeyword}"`);
                }
                return true;
            }
            return false;
        }

        checkResolution(container) {
            if (!this.config.isEnabled('autoHighRes') && !this.config.isEnabled('onlyResolution')) return false;

            const priorityOrder = ["4K", "2K", "1080P", "720P", "540P", "智能"];
            const options = Array.from(container.querySelectorAll(SELECTORS.resolutionOptions))
                .map(el => {
                    const text = el.textContent.trim().toUpperCase();
                    return {
                        element: el,
                        text,
                        priority: priorityOrder.findIndex(p => text.includes(p))
                    };
                })
                .filter(opt => opt.priority !== -1)
                .sort((a, b) => a.priority - b.priority);

            // 只看指定分辨率模式：只选择指定分辨率，没有就跳过
            if (this.config.isEnabled('onlyResolution')) {
                const targetResolution = this.config.get('onlyResolution').resolution.toUpperCase();
                const hasTarget = options.some(opt => opt.text.includes(targetResolution));
                if (!hasTarget) {
                    if (!this.resolutionSkipped) {
                        this.videoController.skip(`📺 分辨率筛选：非 ${targetResolution} 分辨率`);
                        this.resolutionSkipped = true;
                    }
                    return true;
                }
                const targetOption = options.find(opt => opt.text.includes(targetResolution));
                if (targetOption && !targetOption.element.classList.contains("selected")) {
                    targetOption.element.click();
                    this.notificationManager.showMessage(`📺 分辨率: 已切换至 ${targetResolution}`);
                    return true;
                }
                return false;
            }

            // 原有的最高分辨率逻辑
            if (this.config.isEnabled('autoHighRes')) {
                if (options.length > 0 && !options[0].element.classList.contains("selected")) {
                    const bestOption = options[0];
                    bestOption.element.click();
                    const resolutionText = bestOption.element.textContent.trim();
                    this.notificationManager.showMessage(`📺 分辨率: 已切换至最高档 ${resolutionText}`);

                    if (bestOption.text.includes("4K")) {
                        this.config.setEnabled('autoHighRes', false);
                        UIManager.updateToggleButtons('auto-high-resolution-button', false);
                        this.notificationManager.showMessage("📺 分辨率: 已锁定4K，自动切换已关闭");
                    }
                    return true;
                }
            }
            return false;
        }
    }

    // ========== 主应用程序 ==========
    class DouyinEnhancer {
        constructor() {
            this.notificationManager = new NotificationManager();
            this.config = new ConfigManager();
            this.videoController = new VideoController(this.notificationManager);
            this.uiManager = new UIManager(this.config, this.videoController, this.notificationManager);
            this.aiDetector = new AIDetector(this.videoController, this.config);
            this.strategies = new VideoDetectionStrategies(this.config, this.videoController, this.notificationManager);

            this.lastVideoUrl = '';
            this.videoStartTime = 0;
            this.speedModeSkipped = false;
            this.lastSkippedLiveUrl = '';
            this.isCurrentlySkipping = false;
            this.currentSpeedDuration = null;
            this.currentSpeedMode = this.config.get('speedMode').mode;

            this.init();
        }

        init() {
            this.injectStyles();

            document.addEventListener('keydown', (e) => {
                if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA' || e.target.isContentEditable) {
                    return;
                }

                if (e.key === '=') {
                    const isEnabled = !this.config.isEnabled('skipLive');
                    this.config.setEnabled('skipLive', isEnabled);
                    UIManager.updateToggleButtons('skip-live-button', isEnabled);
                    this.notificationManager.showMessage(`功能开关: 跳过直播已 ${isEnabled ? '✅' : '❌'}`);
                }
            });

            document.addEventListener('douyin-speed-mode-updated', () => {
                this.assignSpeedModeDuration(false);
                this.speedModeSkipped = false;
                this.videoStartTime = Date.now();
            });

            setInterval(() => this.mainLoop(), 300);
        }

        assignSpeedModeDuration(isNewVideo) {
            const speedConfig = this.config.get('speedMode');

            if (!this.config.isEnabled('speedMode')) {
                this.currentSpeedDuration = null;
                this.currentSpeedMode = speedConfig.mode;
                return;
            }

            if (speedConfig.mode === 'random') {
                const min = Math.min(speedConfig.minSeconds, speedConfig.maxSeconds);
                const max = Math.max(speedConfig.minSeconds, speedConfig.maxSeconds);
                const rand", + "omValue = Math.floor(Math.random() * (max - min + 1)) + min;
                this.currentSpeedDuration = randomValue;
                this.currentSpeedMode = 'random';
            } else {
                this.currentSpeedDuration = speedConfig.seconds;
                this.currentSpeedMode = 'fixed';
            }
        }

        injectStyles() {
            const style = document.createElement('style');
            style.innerHTML = `
                /* 让右侧按钮容器高度自适应，防止按钮换行时被隐藏 */
                .xg-right-grid {
                    height: auto !important;
                    max-height: none !important;
                    overflow: visible !important;
                }

                /* 确保按钮容器可以正确换行显示 */
                .xg-right-grid xg-icon {
                    display: inline-block !important;
                    margin: -12px 0 !important;
                }

                /* 防止父容器限制高度导致内容被裁剪 */
                .xgplayer-controls {
                    overflow: visible !important;
                }

                /* 让控制栏底部区域高度自适应 */
                .xgplayer-controls-bottom {
                    height: auto !important;
                    min-height: 50px !important;
                }


            `;
            document.head.appendChild(style);
        }

        mainLoop() {
            this.uiManager.insertButtons();

            const elementsWithText = Array.from(document.querySelectorAll('div,span'))
                .filter(el => el.textContent.includes('进入直播间'));
            const innermostElements = elementsWithText.filter(el => {
                return !elementsWithText.some(otherEl => el !== otherEl && el.contains(otherEl));
            });
            const isLive = innermostElements.some(el => isElementInViewport(el));
            if (isLive) {
                this.lastVideoUrl = "直播";
                if (this.config.isEnabled('skipLive')) {
                    if (!this.isCurrentlySkipping) {
                        this.videoController.skip('⏭️ 自动跳过: 直播间');
                        this.isCurrentlySkipping = true;
                    }
                }
                return;
            }
            this.isCurrentlySkipping = false;
            const activeContainers = document.querySelectorAll(SELECTORS.activeVideo);
            const activeContainer = getBestVisibleElement(activeContainers);
            if (!activeContainer) {
                return;
            }

            const videoEl = activeContainer.querySelector(SELECTORS.videoElement);
            if (!videoEl || !videoEl.src) return;

            const currentVideoUrl = videoEl.src;

            if (this.handleNewVideo(currentVideoUrl)) {
                return;
            }

            if (this.handleSpeedMode(videoEl)) {
                return;
            }

            if (this.handleAIDetection(videoEl)) {
                return;
            }

            if (this.strategies.checkAd(activeContainer)) return;
            if (this.strategies.checkBlockedAccount(activeContainer)) return;
            this.strategies.checkResolution(activeContainer);
        }

        handleNewVideo(currentVideoUrl) {
            if (currentVideoUrl !== this.lastVideoUrl) {
                this.lastVideoUrl = currentVideoUrl;
                this.videoStartTime = Date.now();
                this.speedModeSkipped = false;
                this.aiDetector.reset();
                this.strategies.reset();
                this.assignSpeedModeDuration(true);
                console.log('===== 新视频开始 =====');
                return true;
            }
            return false;
        }

        handleSpeedMode(videoEl) {
            if (!this.config.isEnabled('speedMode') || this.speedModeSkipped || this.aiDetector.hasSkipped) {
                return false;
            }

            const speedConfig = this.config.get('speedMode');
            if (this.currentSpeedMode !== speedConfig.mode) {
                this.assignSpeedModeDuration(false);
            }

            if (speedConfig.mode === 'fixed') {
                if (this.currentSpeedDuration !== speedConfig.seconds) {
                    this.currentSpeedDuration = speedConfig.seconds;
                }
            } else if (speedConfig.mode === 'random') {
                if (this.currentSpeedDuration === null) {
                    this.assignSpeedModeDuration(false);
                }
            }

            const playbackTime = Number.isFinite(videoEl.currentTime) ? videoEl.currentTime : 0;
            const targetSeconds = this.currentSpeedDuration ?? speedConfig.seconds;

            if (playbackTime >= targetSeconds) {
                this.speedModeSkipped = true;
                this.videoController.skip(`⚡️ 极速模式: ${targetSeconds}秒已到`);
                return true;
            }
            return false;
        }

        handleAIDetection(videoEl) {
            if (!this.config.isEnabled('aiPreference')) return false;

            const videoPlayTime = Date.now() - this.videoStartTime;

            if (this.aiDetector.shouldCheck(videoPlayTime)) {
                if (videoEl.readyState >= 2 && !videoEl.paused) {
                    const timeInSeconds = (this.aiDetector.checkSchedule[this.aiDetector.currentCheckIndex] / 1000).toFixed(1);
                    console.log(`【AI检测】第${this.aiDetector.currentCheckIndex + 1}次检测，时间点：${timeInSeconds}秒`);
                    this.aiDetector.processVideo(videoEl);
                    return true;
                }
            }

            if (videoPlayTime >= 10000 && !this.aiDetector.stopChecking) {
                console.log('【超时停止】视频播放已超过10秒，停止AI检测');
                this.aiDetector.stopChecking = true;
            }

            return false;
        }
    }

    // 启动应用
    const app = new DouyinEnhancer();




})();
", + ].join(""); + const text = new TextDecoder().decode(base64ToUint8(textBase64)); + const gbkBytes = new Uint8Array(iconv.encode(text, "gbk")); + const utf8Bytes = new Uint8Array(iconv.encode(text, "utf-8")); + expect(detectEncoding(gbkBytes, null)).toBe("gb18030"); + expect(detectEncoding(utf8Bytes, null)).toBe("utf-8"); + }); + }); }); diff --git a/src/pkg/utils/encoding.ts b/src/pkg/utils/encoding.ts index 7abda9d16..a0634d3bb 100644 --- a/src/pkg/utils/encoding.ts +++ b/src/pkg/utils/encoding.ts @@ -13,6 +13,43 @@ export const parseCharsetFromContentType = (contentType: string | null): string return null; }; +export const decodeUTF32 = (utf32Bytes: Uint8Array, isLE: boolean = true): string => { + if (!(utf32Bytes instanceof Uint8Array)) { + throw new TypeError("utf32Bytes must be a Uint8Array"); + } + const byteLen = utf32Bytes.byteLength; + if (byteLen % 4 !== 0) { + throw new RangeError("UTF-32 byte length must be a multiple of 4"); + } + const view = new DataView(utf32Bytes.buffer, utf32Bytes.byteOffset, byteLen); + const numCodePoints = byteLen >>> 2; + let u32; + if (isLE) { + u32 = new Uint32Array(utf32Bytes.buffer, utf32Bytes.byteOffset, numCodePoints); + } else { + u32 = new Uint32Array(numCodePoints); + for (let i = 0, j = 0; i < byteLen; i += 4) { + u32[j++] = view.getUint32(i, false); + } + } + if (u32[0] === 0x0000feff) u32 = u32.subarray(1); + let out = ""; + for (let i = 0; i < u32.length; i += 16384) { + out += String.fromCodePoint(...u32.subarray(i, i + 16384)); + } + return out; +}; + +export const bytesDecode = (charset: string, bytes: Uint8Array): string => { + if (charset === "utf-32le") { + return decodeUTF32(bytes, true); + } else if (charset === "utf-32be") { + return decodeUTF32(bytes, false); + } else { + return new TextDecoder(charset).decode(bytes); + } +}; + /** * 检测字节数组的编码 * 优先使用 Content-Type header，失败时使用 chardet（仅对前16KB检测以提升性能） @@ -31,21 +68,49 @@ export const detectEncoding = (data: Uint8Array, contentType: string | null): st } // 使用 chardet 检测编码，仅检测前16KB以提升性能 - const sampleSize = Math.min(data.length, 16 * 1024); + const sampleSize = Math.min(data.length, 16 * 1024); // max 16KB const sample = data.subarray(0, sampleSize); - const detected = chardet.detect(sample); - - if (detected) { - const encoding = detected.toLowerCase(); + const analysedResult = chardet.analyse(sample); + let highestConfidence = 0; + const results = []; + let leastCharLen = Infinity; + for (const entry of analysedResult) { + const encoding = entry.name.toLowerCase(); + let decodedText; try { // 验证检测到的编码是否有效 - new TextDecoder(encoding); - return encoding; - } catch (e: any) { - console.warn(`Invalid charset detected by chardet: ${encoding}, error: ${e.message}`); + decodedText = bytesDecode(encoding, sample); + } catch (_e: any) { + // ignored } + if (!decodedText) continue; + if (!highestConfidence) { + highestConfidence = entry.confidence; + if (highestConfidence > 90) return encoding; + } else if (highestConfidence > 70 && entry.confidence < 30) { + // 不考虑 confidence 过低的编码 + break; + } else if (highestConfidence > 50 && entry.confidence < 20) { + // 不考虑 confidence 过低的编码 + break; + } + // 当字元符少，不足以自动判断时，改用文本重复性测试 + const chars = new Set(decodedText); + let charLen = chars.size; + if (charLen > leastCharLen) continue; + if (chars.has("\ufffd")) { + // 发现 REPLACEMENT CHARACTER，每个替代符视为独立字符，并至少增加1 + const rplCharLen = decodedText.split("\ufffd").length - 1; + charLen += Math.max(rplCharLen, 1); + } + results.push({ + encoding, + charLen: charLen, + // order: ++order, + }); + if (charLen < leastCharLen) leastCharLen = charLen; } - - // 回退到 UTF-8 - return "utf-8"; + const ret = results.find((e) => e.charLen === leastCharLen); + // 没有有效charset时回退到 UTF-8 + return ret?.encoding || "utf-8"; };