视频教程：#

免费VPN 10分钟快速自建流畅使用Gemini 基于cloudflare 小白友好最新现场详细完整演示教程数十节点任意切换

操作步骤：#

1️⃣ 注册免费域名：点此注册

2️⃣ 下载客户端软件：桌面版（Windows、Linux、macOS），安卓手机版

3️⃣ 注册 cloudflare 账号： Cloudflare

4️⃣绑定域名到 cloudflare

5️⃣ 构建 worker 并配置

6️⃣ 配置优选 IP

7️⃣ 配置 proxyIP

8️⃣ 获取订阅地址

9️⃣ 配置代理

🔟 开始使用

Cloudflare 官网：随时随地连接、保护和构建 | Cloudflare

免费域名注册网站：DNSHE | 永久免费的域名注册与 DNS 解析服务

优选订阅地址：#

1
Cm.Soso.Edu.Kg
2
Sub.Cmliussss.Net
3
Owo.O00o.Ooo

PROXYIP 订阅:#

1
ProxyIP.US.CMLiussss.Net
2
ProxyIP.SG.CMLiussss.Net
3
ProxyIP.JP.CMLiussss.Net

Worker 代码：代码链接 #

1
import { connect } from "cloudflare:sockets";
2
let config_JSON, 反代IP = '', 启用SOCKS5反代 = null, 启用SOCKS5全局反代 = false, 我的SOCKS5账号 = '', parsedSocks5Address = {};
3
let SOCKS5白名单 = ['*tapecontent.net', '*cloudatacdn.com', '*loadshare.org', '*cdn-centaurus.com', 'scholar.google.com'];
4
const Pages静态页面 = 'https://edt-pages.github.io';
5
///////////////////////////////////////////////////////主程序入口///////////////////////////////////////////////
6
export default {
7
    async fetch(request, env, ctx) {
8
        const url = new URL(request.url);
9
        const UA = request.headers.get('User-Agent') || 'null';
10
        const upgradeHeader = request.headers.get('Upgrade');
11
        const 管理员密码 = env.ADMIN || env.admin || env.PASSWORD || env.password || env.pswd || env.TOKEN || env.KEY || env.UUID || env.uuid;
12
        const 加密秘钥 = env.KEY || '勿动此默认密钥，有需求请自行通过添加变量KEY进行修改';
13
        const userIDMD5 = await MD5MD5(管理员密码 + 加密秘钥);
14
        const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
15
        const envUUID = env.UUID || env.uuid;
16
        const userID = (envUUID && uuidRegex.test(envUUID)) ? envUUID.toLowerCase() : [userIDMD5.slice(0, 8), userIDMD5.slice(8, 12), '4' + userIDMD5.slice(13, 16), '8' + userIDMD5.slice(17, 20), userIDMD5.slice(20)].join('-');
17
        const hosts = env.HOST ? (await 整理成数组(env.HOST)).map(h => h.toLowerCase().replace(/^https?:\/\//, '').split('/')[0].split(':')[0]) : [url.hostname];
18
        const host = hosts[0];
19
        if (env.PROXYIP) {
20
            const proxyIPs = await 整理成数组(env.PROXYIP);
21
            反代IP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)];
22
        } else 反代IP = (request.cf.colo + '.PrOxYIp.CmLiUsSsS.nEt').toLowerCase();
23
        const 访问IP = request.headers.get('X-Real-IP') || request.headers.get('CF-Connecting-IP') || request.headers.get('X-Forwarded-For') || request.headers.get('True-Client-IP') || request.headers.get('Fly-Client-IP') || request.headers.get('X-Appengine-Remote-Addr') || request.headers.get('X-Forwarded-For') || request.headers.get('X-Real-IP') || request.headers.get('X-Cluster-Client-IP') || request.cf?.clientTcpRtt || '未知IP';
24
        if (env.GO2SOCKS5) SOCKS5白名单 = await 整理成数组(env.GO2SOCKS5);
25
        if (!upgradeHeader || upgradeHeader !== 'websocket') {
26
            if (url.protocol === 'http:') return Response.redirect(url.href.replace(`http://${url.hostname}`, `https://${url.hostname}`), 301);
27
            if (!管理员密码) return fetch(Pages静态页面 + '/noADMIN').then(r => { const headers = new Headers(r.headers); headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate'); headers.set('Pragma', 'no-cache'); headers.set('Expires', '0'); return new Response(r.body, { status: 404, statusText: r.statusText, headers }); });
28
            if (!env.KV) return fetch(Pages静态页面 + '/noKV').then(r => { const headers = new Headers(r.headers); headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate'); headers.set('Pragma', 'no-cache'); headers.set('Expires', '0'); return new Response(r.body, { status: 404, statusText: r.statusText, headers }); });
29
            const 访问路径 = url.pathname.slice(1).toLowerCase();
30
            const 区分大小写访问路径 = url.pathname.slice(1);
31
            if (访问路径 === 加密秘钥 && 加密秘钥 !== '勿动此默认密钥，有需求请自行通过添加变量KEY进行修改') {//快速订阅
32
                const params = new URLSearchParams(url.search);
33
                params.set('token', await MD5MD5(host + userID));
34
                return new Response('重定向中...', { status: 302, headers: { 'Location': `/sub?${params.toString()}` } });
35
            } else if (访问路径 === 'login') {//处理登录页面和登录请求
36
                const cookies = request.headers.get('Cookie') || '';
37
                const authCookie = cookies.split(';').find(c => c.trim().startsWith('auth='))?.split('=')[1];
38
                if (authCookie == await MD5MD5(UA + 加密秘钥 + 管理员密码)) return new Response('重定向中...', { status: 302, headers: { 'Location': '/admin' } });
39
                if (request.method === 'POST') {
40
                    const formData = await request.text();
41
                    const params = new URLSearchParams(formData);
42
                    const 输入密码 = params.get('password');
43
                    if (输入密码 === 管理员密码) {
44
                        // 密码正确，设置cookie并返回成功标记
45
                        const 响应 = new Response(JSON.stringify({ success: true }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
46
                        响应.headers.set('Set-Cookie', `auth=${await MD5MD5(UA + 加密秘钥 + 管理员密码)}; Path=/; Max-Age=86400; HttpOnly`);
47
                        return 响应;
48
                    }
49
                }
50
                return fetch(Pages静态页面 + '/login');
51
            } else if (访问路径 === 'admin' || 访问路径.startsWith('admin/')) {//验证cookie后响应管理页面
52
                const cookies = request.headers.get('Cookie') || '';
53
                const authCookie = cookies.split(';').find(c => c.trim().startsWith('auth='))?.split('=')[1];
54
                // 没有cookie或cookie错误，跳转到/login页面
55
                if (!authCookie || authCookie !== await MD5MD5(UA + 加密秘钥 + 管理员密码)) return new Response('重定向中...', { status: 302, headers: { 'Location': '/login' } });
56
                if (访问路径 === 'admin/log.json') {// 读取日志内容
57
                    const 读取日志内容 = await env.KV.get('log.json') || '[]';
58
                    return new Response(读取日志内容, { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
59
                } else if (区分大小写访问路径 === 'admin/getCloudflareUsage') {// 查询请求量
60
                    try {
61
                        const Usage_JSON = await getCloudflareUsage(url.searchParams.get('Email'), url.searchParams.get('GlobalAPIKey'), url.searchParams.get('AccountID'), url.searchParams.get('APIToken'));
62
                        return new Response(JSON.stringify(Usage_JSON, null, 2), { status: 200, headers: { 'Content-Type': 'application/json' } });
63
                    } catch (err) {
64
                        const errorResponse = { msg: '查询请求量失败，失败原因：' + err.message, error: err.message };
65
                        return new Response(JSON.stringify(errorResponse, null, 2), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
66
                    }
67
                } else if (区分大小写访问路径 === 'admin/getADDAPI') {// 验证优选API
68
                    if (url.searchParams.get('url')) {
69
                        const 待验证优选URL = url.searchParams.get('url');
70
                        try {
71
                            new URL(待验证优选URL);
72
                            const 优选API的IP = await 请求优选API([待验证优选URL], url.searchParams.get('port') || '443');
73
                            return new Response(JSON.stringify({ success: true, data: 优选API的IP }, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
74
                        } catch (err) {
75
                            const errorResponse = { msg: '验证优选API失败，失败原因：' + err.message, error: err.message };
76
                            return new Response(JSON.stringify(errorResponse, null, 2), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
77
                        }
78
                    }
79
                    return new Response(JSON.stringify({ success: false, data: [] }, null, 2), { status: 403, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
80
                } else if (访问路径 === 'admin/check') {// SOCKS5代理检查
81
                    let 检测代理响应;
82
                    if (url.searchParams.has('socks5')) {
83
                        检测代理响应 = await SOCKS5可用性验证('socks5', url.searchParams.get('socks5'));
84
                    } else if (url.searchParams.has('http')) {
85
                        检测代理响应 = await SOCKS5可用性验证('http', url.searchParams.get('http'));
86
                    } else {
87
                        return new Response(JSON.stringify({ error: '缺少代理参数' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
88
                    }
89
                    return new Response(JSON.stringify(检测代理响应, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
90
                }
91

92
                config_JSON = await 读取config_JSON(env, host, userID, env.PATH);
93

94
                if (访问路径 === 'admin/init') {// 重置配置为默认值
95
                    try {
96
                        config_JSON = await 读取config_JSON(env, host, userID, env.PATH, true);
97
                        ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Init_Config', config_JSON));
98
                        config_JSON.init = '配置已重置为默认值';
99
                        return new Response(JSON.stringify(config_JSON, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
100
                    } catch (err) {
101
                        const errorResponse = { msg: '配置重置失败，失败原因：' + err.message, error: err.message };
102
                        return new Response(JSON.stringify(errorResponse, null, 2), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
103
                    }
104
                } else if (request.method === 'POST') {// 处理 KV 操作（POST 请求）
105
                    if (访问路径 === 'admin/config.json') { // 保存config.json配置
106
                        try {
107
                            const newConfig = await request.json();
108
                            // 验证配置完整性
109
                            if (!newConfig.UUID || !newConfig.HOST) return new Response(JSON.stringify({ error: '配置不完整' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
110

111
                            // 保存到 KV
112
                            await env.KV.put('config.json', JSON.stringify(newConfig, null, 2));
113
                            ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Config', config_JSON));
114
                            return new Response(JSON.stringify({ success: true, message: '配置已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
115
                        } catch (error) {
116
                            console.error('保存配置失败:', error);
117
                            return new Response(JSON.stringify({ error: '保存配置失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
118
                        }
119
                    } else if (访问路径 === 'admin/cf.json') { // 保存cf.json配置
120
                        try {
121
                            const newConfig = await request.json();
122
                            const CF_JSON = { Email: null, GlobalAPIKey: null, AccountID: null, APIToken: null };
123
                            if (!newConfig.init || newConfig.init !== true) {
124
                                if (newConfig.Email && newConfig.GlobalAPIKey) {
125
                                    CF_JSON.Email = newConfig.Email;
126
                                    CF_JSON.GlobalAPIKey = newConfig.GlobalAPIKey;
127
                                    CF_JSON.AccountID = null;
128
                                    CF_JSON.APIToken = null;
129
                                } else if (newConfig.AccountID && newConfig.APIToken) {
130
                                    CF_JSON.Email = null;
131
                                    CF_JSON.GlobalAPIKey = null;
132
                                    CF_JSON.AccountID = newConfig.AccountID;
133
                                    CF_JSON.APIToken = newConfig.APIToken;
134
                                } else {
135
                                    return new Response(JSON.stringify({ error: '配置不完整' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
136
                                }
137
                            }
138

139
                            // 保存到 KV
140
                            await env.KV.put('cf.json', JSON.stringify(CF_JSON, null, 2));
141
                            ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Config', config_JSON));
142
                            return new Response(JSON.stringify({ success: true, message: '配置已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
143
                        } catch (error) {
144
                            console.error('保存配置失败:', error);
145
                            return new Response(JSON.stringify({ error: '保存配置失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
146
                        }
147
                    } else if (访问路径 === 'admin/tg.json') { // 保存tg.json配置
148
                        try {
149
                            const newConfig = await request.json();
150
                            if (newConfig.init && newConfig.init === true) {
151
                                const TG_JSON = { BotToken: null, ChatID: null };
152
                                await env.KV.put('tg.json', JSON.stringify(TG_JSON, null, 2));
153
                            } else {
154
                                if (!newConfig.BotToken || !newConfig.ChatID) return new Response(JSON.stringify({ error: '配置不完整' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
155
                                await env.KV.put('tg.json', JSON.stringify(newConfig, null, 2));
156
                            }
157
                            ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Config', config_JSON));
158
                            return new Response(JSON.stringify({ success: true, message: '配置已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
159
                        } catch (error) {
160
                            console.error('保存配置失败:', error);
161
                            return new Response(JSON.stringify({ error: '保存配置失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
162
                        }
163
                    } else if (区分大小写访问路径 === 'admin/ADD.txt') { // 保存自定义优选IP
164
                        try {
165
                            const customIPs = await request.text();
166
                            await env.KV.put('ADD.txt', customIPs);// 保存到 KV
167
                            ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Custom_IPs', config_JSON));
168
                            return new Response(JSON.stringify({ success: true, message: '自定义IP已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
169
                        } catch (error) {
170
                            console.error('保存自定义IP失败:', error);
171
                            return new Response(JSON.stringify({ error: '保存自定义IP失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
172
                        }
173
                    } else return new Response(JSON.stringify({ error: '不支持的POST请求路径' }), { status: 404, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
174
                } else if (访问路径 === 'admin/config.json') {// 处理 admin/config.json 请求，返回JSON
175
                    return new Response(JSON.stringify(config_JSON, null, 2), { status: 200, headers: { 'Content-Type': 'application/json' } });
176
                } else if (区分大小写访问路径 === 'admin/ADD.txt') {// 处理 admin/ADD.txt 请求，返回本地优选IP
177
                    let 本地优选IP = await env.KV.get('ADD.txt') || 'null';
178
                    if (本地优选IP == 'null') 本地优选IP = (await 生成随机IP(request, config_JSON.优选订阅生成.本地IP库.随机数量, config_JSON.优选订阅生成.本地IP库.指定端口))[1];
179
                    return new Response(本地优选IP, { status: 200, headers: { 'Content-Type': 'text/plain;charset=utf-8', 'asn': request.cf.asn } });
180
                } else if (访问路径 === 'admin/cf.json') {// CF配置文件
181
                    return new Response(JSON.stringify(request.cf, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } });
182
                }
183

184
                ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Admin_Login', config_JSON));
185
                return fetch(Pages静态页面 + '/admin');
186
            } else if (访问路径 === 'logout') {//清除cookie并跳转到登录页面
187
                const 响应 = new Response('重定向中...', { status: 302, headers: { 'Location': '/login' } });
188
                响应.headers.set('Set-Cookie', 'auth=; Path=/; Max-Age=0; HttpOnly');
189
                return 响应;
190
            } else if (访问路径 === 'sub') {//处理订阅请求
191
                const 订阅TOKEN = await MD5MD5(host + userID);
192
                if (url.searchParams.get('token') === 订阅TOKEN) {
193
                    config_JSON = await 读取config_JSON(env, host, userID, env.PATH);
194
                    ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Get_SUB', config_JSON));
195
                    const ua = UA.toLowerCase();
196
                    const expire = 4102329600;//2099-12-31 到期时间
197
                    const now = Date.now();
198
                    const today = new Date(now);
199
                    today.setHours(0, 0, 0, 0);
200
                    const UD = Math.floor(((now - today.getTime()) / 86400000) * 24 * 1099511627776 / 2);
201
                    let pagesSum = UD, workersSum = UD, total = 24 * 1099511627776;
202
                    if (config_JSON.CF.Usage.success) {
203
                        pagesSum = config_JSON.CF.Usage.pages;
204
                        workersSum = config_JSON.CF.Usage.workers;
205
                        total = 1024 * 100;
206
                    }
207
                    const responseHeaders = {
208
                        "content-type": "text/plain; charset=utf-8",
209
                        "Profile-Update-Interval": config_JSON.优选订阅生成.SUBUpdateTime,
210
                        "Profile-web-page-url": url.protocol + '//' + url.host + '/admin',
211
                        "Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`,
212
                        "Cache-Control": "no-store",
213
                    };
214
                    const isSubConverterRequest = request.headers.has('b64') || request.headers.has('base64') || request.headers.get('subconverter-request') || request.headers.get('subconverter-version') || ua.includes('subconverter') || ua.includes(('CF-Workers-SUB').toLowerCase());
215
                    const 订阅类型 = isSubConverterRequest
216
                        ? 'mixed'
217
                        : url.searchParams.has('target')
218
                            ? url.searchParams.get('target')
219
                            : url.searchParams.has('clash') || ua.includes('clash') || ua.includes('meta') || ua.includes('mihomo')
220
                                ? 'clash'
221
                                : url.searchParams.has('sb') || url.searchParams.has('singbox') || ua.includes('singbox') || ua.includes('sing-box')
222
                                    ? 'singbox'
223
                                    : url.searchParams.has('surge') || ua.includes('surge')
224
                                        ? 'surge&ver=4'
225
                                        : 'mixed';
226

227
                    if (!ua.includes('mozilla')) responseHeaders["Content-Disposition"] = `attachment; filename*=utf-8''${encodeURIComponent(config_JSON.优选订阅生成.SUBNAME)}`;
228
                    const 协议类型 = (url.searchParams.has('surge') || ua.includes('surge')) ? 'tro' + 'jan' : config_JSON.协议类型;
229
                    let 订阅内容 = '';
230
                    if (订阅类型 === 'mixed') {
231
                        const 节点路径 = config_JSON.启用0RTT ? config_JSON.PATH + '?ed=2560' : config_JSON.PATH;
232
                        const TLS分片参数 = config_JSON.TLS分片 == 'Shadowrocket' ? `&fragment=${encodeURIComponent('1,40-60,30-50,tlshello')}` : config_JSON.TLS分片 == 'Happ' ? `&fragment=${encodeURIComponent('3,1,tlshello')}` : '';
233
                        let 完整优选IP = [], 其他节点LINK = '';
234

235
                        if (!url.searchParams.has('sub') && config_JSON.优选订阅生成.local) { // 本地生成订阅
236
                            const 完整优选列表 = config_JSON.优选订阅生成.本地IP库.随机IP ? (await 生成随机IP(request, config_JSON.优选订阅生成.本地IP库.随机数量, config_JSON.优选订阅生成.本地IP库.指定端口))[0] : await env.KV.get('ADD.txt') ? await 整理成数组(await env.KV.get('ADD.txt')) : (await 生成随机IP(request, config_JSON.优选订阅生成.本地IP库.随机数量, config_JSON.优选订阅生成.本地IP库.指定端口))[0];
237
                            const 优选API = [], 优选IP = [], 其他节点 = [];
238
                            for (const 元素 of 完整优选列表) {
239
                                if (元素.toLowerCase().startsWith('https://')) 优选API.push(元素);
240
                                else if (元素.toLowerCase().includes('://')) 其他节点.push(元素);
241
                                else 优选IP.push(元素);
242
                            }
243
                            其他节点LINK = 其他节点.join('\n') + '\n';
244
                            const 优选API的IP = await 请求优选API(优选API);
245
                            完整优选IP = [...new Set(优选IP.concat(优选API的IP))];
246
                        } else { // 优选订阅生成器
247
                            let 优选订阅生成器HOST = url.searchParams.get('sub') || config_JSON.优选订阅生成.SUB;
248
                            优选订阅生成器HOST = 优选订阅生成器HOST && !/^https?:\/\//i.test(优选订阅生成器HOST) ? `https://${优选订阅生成器HOST}` : 优选订阅生成器HOST;
249
                            const 优选订阅生成器URL = `${优选订阅生成器HOST}/sub?host=example.com&uuid=00000000-0000-4000-8000-000000000000`;
250
                            try {
251
                                const response = await fetch(优选订阅生成器URL, { headers: { 'User-Agent': 'v2rayN/edge' + 'tunnel (https://github.com/cmliu/edge' + 'tunnel)' } });
252
                                if (!response.ok) return new Response('优选订阅生成器异常：' + response.statusText, { status: response.status });
253
                                const 优选订阅生成器返回订阅内容 = atob(await response.text());
254
                                const 订阅行列表 = 优选订阅生成器返回订阅内容.includes('\r\n') ? 优选订阅生成器返回订阅内容.split('\r\n') : 优选订阅生成器返回订阅内容.split('\n');
255
                                for (const 行内容 of 订阅行列表) {
256
                                    if (!行内容.trim()) continue; // 跳过空行
257
                                    if (行内容.includes('00000000-0000-4000-8000-000000000000') && 行内容.includes('example.com')) { // 这是优选IP行，提取 域名:端口#备注
258
                                        const 地址匹配 = 行内容.match(/:\/\/[^@]+@([^?]+)/);
259
                                        if (地址匹配) {
260
                                            let 地址端口 = 地址匹配[1], 备注 = ''; // 域名:端口 或 IP:端口
261
                                            const 备注匹配 = 行内容.match(/#(.+)$/);
262
                                            if (备注匹配) 备注 = '#' + decodeURIComponent(备注匹配[1]);
263
                                            完整优选IP.push(地址端口 + 备注);
264
                                        }
265
                                    } else 其他节点LINK += 行内容 + '\n';
266
                                }
267
                            } catch (error) {
268
                                return new Response('优选订阅生成器异常：' + error.message, { status: 403 });
269
                            }
270
                        }
271

272
                        订阅内容 = 完整优选IP.map(原始地址 => {
273
                            // 统一正则: 匹配 域名/IPv4/IPv6地址 + 可选端口 + 可选备注
274
                            // 示例:
275
                            //   - 域名: hj.xmm1993.top:2096#备注 或 example.com
276
                            //   - IPv4: 166.0.188.128:443#Los Angeles 或 166.0.188.128
277
                            //   - IPv6: [2606:4700::]:443#CMCC 或 [2606:4700::]
278
                            const regex = /^(\[[\da-fA-F:]+\]|[\d.]+|[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*)(?::(\d+))?(?:#(.+))?$/;
279
                            const match = 原始地址.match(regex);
280

281
                            let 节点地址, 节点端口 = "443", 节点备注;
282

283
                            if (match) {
284
                                节点地址 = match[1];  // IP地址或域名(可能带方括号)
285
                                节点端口 = match[2] || "443";  // 端口,默认443
286
                                节点备注 = match[3] || 节点地址;  // 备注,默认为地址本身
287
                            } else {
288
                                // 不规范的格式，跳过处理返回null
289
                                console.warn(`[订阅内容] 不规范的IP格式已忽略: ${原始地址}`);
290
                                return null;
291
                            }
292

293
                            return `${协议类型}://00000000-0000-4000-8000-000000000000@${节点地址}:${节点端口}?security=tls&type=${config_JSON.传输协议}&host=example.com&sni=example.com&path=${encodeURIComponent(config_JSON.随机路径 ? 随机路径() + 节点路径 : 节点路径) + TLS分片参数}&encryption=none${config_JSON.跳过证书验证 ? '&allowInsecure=1' : ''}#${encodeURIComponent(节点备注)}`;
294
                        }).filter(item => item !== null).join('\n');
295
                    } else { // 订阅转换
296
                        const 订阅转换URL = `${config_JSON.订阅转换配置.SUBAPI}/sub?target=${订阅类型}&url=${encodeURIComponent(url.protocol + '//' + url.host + '/sub?target=mixed&token=' + 订阅TOKEN + (url.searchParams.has('sub') && url.searchParams.get('sub') != '' ? `&sub=${url.searchParams.get('sub')}` : ''))}&config=${encodeURIComponent(config_JSON.订阅转换配置.SUBCONFIG)}&emoji=${config_JSON.订阅转换配置.SUBEMOJI}&scv=${config_JSON.跳过证书验证}`;
297
                        try {
298
                            const response = await fetch(订阅转换URL, { headers: { 'User-Agent': 'Subconverter for ' + 订阅类型 + ' edge' + 'tunnel(https://github.com/cmliu/edge' + 'tunnel)' } });
299
                            if (response.ok) {
300
                                订阅内容 = await response.text();
301
                                if (url.searchParams.has('surge') || ua.includes('surge')) 订阅内容 = surge(订阅内容, url.protocol + '//' + url.host + '/sub?token=' + 订阅TOKEN + '&surge', config_JSON);
302
                            } else return new Response('订阅转换后端异常：' + response.statusText, { status: response.status });
303
                        } catch (error) {
304
                            return new Response('订阅转换后端异常：' + error.message, { status: 403 });
305
                        }
306
                    }
307

308
                    if (!ua.includes('subconverter')) 订阅内容 = 批量替换域名(订阅内容.replace(/00000000-0000-4000-8000-000000000000/g, config_JSON.UUID), config_JSON.HOSTS)
309

310
                    if (!ua.includes('mozilla') && 订阅类型 === 'mixed') 订阅内容 = btoa(订阅内容);
311

312
                    if (订阅类型 === 'singbox') {
313
                        订阅内容 = JSON.stringify(JSON.parse(订阅内容), null, 2);
314
                        responseHeaders["content-type"] = 'application/json; charset=utf-8';
315
                    } else if (订阅类型 === 'clash') {
316
                        responseHeaders["content-type"] = 'application/x-yaml; charset=utf-8';
317
                    }
318
                    return new Response(订阅内容, { status: 200, headers: responseHeaders });
319
                }
320
                return new Response('无效的订阅TOKEN', { status: 403 });
321
            } else if (访问路径 === 'locations') return fetch(new Request('https://speed.cloudflare.com/locations', { headers: { 'Referer': 'https://speed.cloudflare.com/' } }));
322
        } else if (管理员密码) {// ws代理
323
            await 反代参数获取(request);
324
            return await 处理WS请求(request, userID);
325
        }
326

327
        let 伪装页URL = env.URL || 'nginx';
328
        if (伪装页URL && 伪装页URL !== 'nginx' && 伪装页URL !== '1101') {
329
            伪装页URL = 伪装页URL.trim().replace(/\/$/, '');
330
            if (!伪装页URL.match(/^https?:\/\//i)) 伪装页URL = 'https://' + 伪装页URL;
331
            if (伪装页URL.toLowerCase().startsWith('http://')) 伪装页URL = 'https://' + 伪装页URL.substring(7);
332
            try { const u = new URL(伪装页URL); 伪装页URL = u.protocol + '//' + u.host; } catch (e) { 伪装页URL = 'nginx'; }
333
        }
334
        if (伪装页URL === '1101') return new Response(await html1101(url.host, 访问IP), { status: 200, headers: { 'Content-Type': 'text/html; charset=UTF-8' } });
335
        try {
336
            const 反代URL = new URL(伪装页URL), 新请求头 = new Headers(request.headers);
337
            新请求头.set('Host', 反代URL.host);
338
            if (新请求头.has('Referer')) { const u = new URL(新请求头.get('Referer')); 新请求头.set('Referer', 反代URL.protocol + '//' + 反代URL.host + u.pathname + u.search); }
339
            if (新请求头.has('Origin')) 新请求头.set('Origin', 反代URL.protocol + '//' + 反代URL.host);
340
            if (!新请求头.has('User-Agent') && UA && UA !== 'null') 新请求头.set('User-Agent', UA);
341
            return fetch(new Request(反代URL.protocol + 反代URL.host + url.pathname + url.search, { method: request.method, headers: 新请求头, body: request.body, cf: request.cf }));
342
        } catch (error) { }
343
        return new Response(await nginx(), { status: 200, headers: { 'Content-Type': 'text/html; charset=UTF-8' } });
344
    }
345
};
346
///////////////////////////////////////////////////////////////////////WS传输数据///////////////////////////////////////////////
347
async function 处理WS请求(request, yourUUID) {
348
    const wssPair = new WebSocketPair();
349
    const [clientSock, serverSock] = Object.values(wssPair);
350
    serverSock.accept();
351
    let remoteConnWrapper = { socket: null };
352
    let isDnsQuery = false;
353
    const earlyData = request.headers.get('sec-websocket-protocol') || '';
354
    const readable = makeReadableStr(serverSock, earlyData);
355
    let 判断是否是木马 = null;
356
    readable.pipeTo(new WritableStream({
357
        async write(chunk) {
358
            if (isDnsQuery) return await forwardataudp(chunk, serverSock, null);
359
            if (remoteConnWrapper.socket) {
360
                const writer = remoteConnWrapper.socket.writable.getWriter();
361
                await writer.write(chunk);
362
                writer.releaseLock();
363
                return;
364
            }
365

366
            if (判断是否是木马 === null) {
367
                const bytes = new Uint8Array(chunk);
368
                判断是否是木马 = bytes.byteLength >= 58 && bytes[56] === 0x0d && bytes[57] === 0x0a;
369
            }
370

371
            if (remoteConnWrapper.socket) {
372
                const writer = remoteConnWrapper.socket.writable.getWriter();
373
                await writer.write(chunk);
374
                writer.releaseLock();
375
                return;
376
            }
377

378
            if (判断是否是木马) {
379
                const { port, hostname, rawClientData } = 解析木马请求(chunk, yourUUID);
380
                if (isSpeedTestSite(hostname)) throw new Error('Speedtest site is blocked');
381
                await forwardataTCP(hostname, port, rawClientData, serverSock, null, remoteConnWrapper);
382
            } else {
383
                const { port, hostname, rawIndex, version, isUDP } = 解析魏烈思请求(chunk, yourUUID);
384
                if (isSpeedTestSite(hostname)) throw new Error('Speedtest site is blocked');
385
                if (isUDP) {
386
                    if (port === 53) isDnsQuery = true;
387
                    else throw new Error('UDP is not supported');
388
                }
389
                const respHeader = new Uint8Array([version[0], 0]);
390
                const rawData = chunk.slice(rawIndex);
391
                if (isDnsQuery) return forwardataudp(rawData, serverSock, respHeader);
392
                await forwardataTCP(hostname, port, rawData, serverSock, respHeader, remoteConnWrapper);
393
            }
394
        },
395
    })).catch((err) => {
396
        // console.error('Readable pipe error:', err);
397
    });
398

399
    return new Response(null, { status: 101, webSocket: clientSock });
400
}
401

402
function 解析木马请求(buffer, passwordPlainText) {
403
    const sha224Password = sha224(passwordPlainText);
404
    if (buffer.byteLength < 56) return { hasError: true, message: "invalid data" };
405
    let crLfIndex = 56;
406
    if (new Uint8Array(buffer.slice(56, 57))[0] !== 0x0d || new Uint8Array(buffer.slice(57, 58))[0] !== 0x0a) return { hasError: true, message: "invalid header format" };
407
    const password = new TextDecoder().decode(buffer.slice(0, crLfIndex));
408
    if (password !== sha224Password) return { hasError: true, message: "invalid password" };
409

410
    const socks5DataBuffer = buffer.slice(crLfIndex + 2);
411
    if (socks5DataBuffer.byteLength < 6) return { hasError: true, message: "invalid S5 request data" };
412

413
    const view = new DataView(socks5DataBuffer);
414
    const cmd = view.getUint8(0);
415
    if (cmd !== 1) return { hasError: true, message: "unsupported command, only TCP is allowed" };
416

417
    const atype = view.getUint8(1);
418
    let addressLength = 0;
419
    let addressIndex = 2;
420
    let address = "";
421
    switch (atype) {
422
        case 1: // IPv4
423
            addressLength = 4;
424
            address = new Uint8Array(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)).join(".");
425
            break;
426
        case 3: // Domain
427
            addressLength = new Uint8Array(socks5DataBuffer.slice(addressIndex, addressIndex + 1))[0];
428
            addressIndex += 1;
429
            address = new TextDecoder().decode(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength));
430
            break;
431
        case 4: // IPv6
432
            addressLength = 16;
433
            const dataView = new DataView(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength));
434
            const ipv6 = [];
435
            for (let i = 0; i < 8; i++) {
436
                ipv6.push(dataView.getUint16(i * 2).toString(16));
437
            }
438
            address = ipv6.join(":");
439
            break;
440
        default:
441
            return { hasError: true, message: `invalid addressType is ${atype}` };
442
    }
443

444
    if (!address) {
445
        return { hasError: true, message: `address is empty, addressType is ${atype}` };
446
    }
447

448
    const portIndex = addressIndex + addressLength;
449
    const portBuffer = socks5DataBuffer.slice(portIndex, portIndex + 2);
450
    const portRemote = new DataView(portBuffer).getUint16(0);
451

452
    return {
453
        hasError: false,
454
        addressType: atype,
455
        port: portRemote,
456
        hostname: address,
457
        rawClientData: socks5DataBuffer.slice(portIndex + 4)
458
    };
459
}
460

461
function 解析魏烈思请求(chunk, token) {
462
    if (chunk.byteLength < 24) return { hasError: true, message: 'Invalid data' };
463
    const version = new Uint8Array(chunk.slice(0, 1));
464
    if (formatIdentifier(new Uint8Array(chunk.slice(1, 17))) !== token) return { hasError: true, message: 'Invalid uuid' };
465
    const optLen = new Uint8Array(chunk.slice(17, 18))[0];
466
    const cmd = new Uint8Array(chunk.slice(18 + optLen, 19 + optLen))[0];
467
    let isUDP = false;
468
    if (cmd === 1) { } else if (cmd === 2) { isUDP = true; } else { return { hasError: true, message: 'Invalid command' }; }
469
    const portIdx = 19 + optLen;
470
    const port = new DataView(chunk.slice(portIdx, portIdx + 2)).getUint16(0);
471
    let addrIdx = portIdx + 2, addrLen = 0, addrValIdx = addrIdx + 1, hostname = '';
472
    const addressType = new Uint8Array(chunk.slice(addrIdx, addrValIdx))[0];
473
    switch (addressType) {
474
        case 1:
475
            addrLen = 4;
476
            hostname = new Uint8Array(chunk.slice(addrValIdx, addrValIdx + addrLen)).join('.');
477
            break;
478
        case 2:
479
            addrLen = new Uint8Array(chunk.slice(addrValIdx, addrValIdx + 1))[0];
480
            addrValIdx += 1;
481
            hostname = new TextDecoder().decode(chunk.slice(addrValIdx, addrValIdx + addrLen));
482
            break;
483
        case 3:
484
            addrLen = 16;
485
            const ipv6 = [];
486
            const ipv6View = new DataView(chunk.slice(addrValIdx, addrValIdx + addrLen));
487
            for (let i = 0; i < 8; i++) ipv6.push(ipv6View.getUint16(i * 2).toString(16));
488
            hostname = ipv6.join(':');
489
            break;
490
        default:
491
            return { hasError: true, message: `Invalid address type: ${addressType}` };
492
    }
493
    if (!hostname) return { hasError: true, message: `Invalid address: ${addressType}` };
494
    return { hasError: false, addressType, port, hostname, isUDP, rawIndex: addrValIdx + addrLen, version };
495
}
496
async function forwardataTCP(host, portNum, rawData, ws, respHeader, remoteConnWrapper) {
497
    console.log(JSON.stringify({ configJSON: { 目标地址: host, 目标端口: portNum, 反代IP: 反代IP, 代理类型: 启用SOCKS5反代, 全局代理: 启用SOCKS5全局反代, 代理账号: 我的SOCKS5账号 } }));
498
    async function connectDirect(address, port, data) {
499
        const remoteSock = connect({ hostname: address, port: port });
500
        const writer = remoteSock.writable.getWriter();
501
        await writer.write(data);
502
        writer.releaseLock();
503
        return remoteSock;
504
    }
505
    async function connecttoPry() {
506
        let newSocket;
507
        if (启用SOCKS5反代 === 'socks5') {
508
            newSocket = await socks5Connect(host, portNum, rawData);
509
        } else if (启用SOCKS5反代 === 'http' || 启用SOCKS5反代 === 'https') {
510
            newSocket = await httpConnect(host, portNum, rawData);
511
        } else {
512
            try {
513
                const [反代IP地址, 反代IP端口] = await 解析地址端口(反代IP);
514
                newSocket = await connectDirect(反代IP地址, 反代IP端口, rawData);
515
            } catch { newSocket = await connectDirect(atob('UFJPWFlJUC50cDEuMDkwMjI3Lnh5eg=='), 1, rawData) }
516
        }
517
        remoteConnWrapper.socket = newSocket;
518
        newSocket.closed.catch(() => { }).finally(() => closeSocketQuietly(ws));
519
        connectStreams(newSocket, ws, respHeader, null);
520
    }
521

522
    const 验证SOCKS5白名单 = (addr) => SOCKS5白名单.some(p => new RegExp(`^${p.replace(/\*/g, '.*')}$`, 'i').test(addr));
523
    if (启用SOCKS5反代 && (启用SOCKS5全局反代 || 验证SOCKS5白名单(host))) {
524
        try {
525
            await connecttoPry();
526
        } catch (err) {
527
            throw err;
528
        }
529
    } else {
530
        try {
531
            const initialSocket = await connectDirect(host, portNum, rawData);
532
            remoteConnWrapper.socket = initialSocket;
533
            connectStreams(initialSocket, ws, respHeader, connecttoPry);
534
        } catch (err) {
535
            await connecttoPry();
536
        }
537
    }
538
}
539

540
async function forwardataudp(udpChunk, webSocket, respHeader) {
541
    try {
542
        const tcpSocket = connect({ hostname: '8.8.4.4', port: 53 });
543
        let vlessHeader = respHeader;
544
        const writer = tcpSocket.writable.getWriter();
545
        await writer.write(udpChunk);
546
        writer.releaseLock();
547
        await tcpSocket.readable.pipeTo(new WritableStream({
548
            async write(chunk) {
549
                if (webSocket.readyState === WebSocket.OPEN) {
550
                    if (vlessHeader) {
551
                        const response = new Uint8Array(vlessHeader.length + chunk.byteLength);
552
                        response.set(vlessHeader, 0);
553
                        response.set(chunk, vlessHeader.length);
554
                        webSocket.send(response.buffer);
555
                        vlessHeader = null;
556
                    } else {
557
                        webSocket.send(chunk);
558
                    }
559
                }
560
            },
561
        }));
562
    } catch (error) {
563
        // console.error('UDP forward error:', error);
564
    }
565
}
566

567
function closeSocketQuietly(socket) {
568
    try {
569
        if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CLOSING) {
570
            socket.close();
571
        }
572
    } catch (error) { }
573
}
574

575
function formatIdentifier(arr, offset = 0) {
576
    const hex = [...arr.slice(offset, offset + 16)].map(b => b.toString(16).padStart(2, '0')).join('');
577
    return `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`;
578
}
579
async function connectStreams(remoteSocket, webSocket, headerData, retryFunc) {
580
    let header = headerData, hasData = false;
581
    await remoteSocket.readable.pipeTo(
582
        new WritableStream({
583
            async write(chunk, controller) {
584
                hasData = true;
585
                if (webSocket.readyState !== WebSocket.OPEN) controller.error('ws.readyState is not open');
586
                if (header) {
587
                    const response = new Uint8Array(header.length + chunk.byteLength);
588
                    response.set(header, 0);
589
                    response.set(chunk, header.length);
590
                    webSocket.send(response.buffer);
591
                    header = null;
592
                } else {
593
                    webSocket.send(chunk);
594
                }
595
            },
596
            abort() { },
597
        })
598
    ).catch((err) => {
599
        closeSocketQuietly(webSocket);
600
    });
601
    if (!hasData && retryFunc) {
602
        await retryFunc();
603
    }
604
}
605

606
function makeReadableStr(socket, earlyDataHeader) {
607
    let cancelled = false;
608
    return new ReadableStream({
609
        start(controller) {
610
            socket.addEventListener('message', (event) => {
611
                if (!cancelled) controller.enqueue(event.data);
612
            });
613
            socket.addEventListener('close', () => {
614
                if (!cancelled) {
615
                    closeSocketQuietly(socket);
616
                    controller.close();
617
                }
618
            });
619
            socket.addEventListener('error', (err) => controller.error(err));
620
            const { earlyData, error } = base64ToArray(earlyDataHeader);
621
            if (error) controller.error(error);
622
            else if (earlyData) controller.enqueue(earlyData);
623
        },
624
        cancel() {
625
            cancelled = true;
626
            closeSocketQuietly(socket);
627
        }
628
    });
629
}
630

631
function isSpeedTestSite(hostname) {
632
    const speedTestDomains = [atob('c3BlZWQuY2xvdWRmbGFyZS5jb20=')];
633
    if (speedTestDomains.includes(hostname)) {
634
        return true;
635
    }
636

637
    for (const domain of speedTestDomains) {
638
        if (hostname.endsWith('.' + domain) || hostname === domain) {
639
            return true;
640
        }
641
    }
642
    return false;
643
}
644

645
function base64ToArray(b64Str) {
646
    if (!b64Str) return { error: null };
647
    try {
648
        const binaryString = atob(b64Str.replace(/-/g, '+').replace(/_/g, '/'));
649
        const bytes = new Uint8Array(binaryString.length);
650
        for (let i = 0; i < binaryString.length; i++) {
651
            bytes[i] = binaryString.charCodeAt(i);
652
        }
653
        return { earlyData: bytes.buffer, error: null };
654
    } catch (error) {
655
        return { error };
656
    }
657
}
658
////////////////////////////////SOCKS5/HTTP函数///////////////////////////////////////////////
659
async function socks5Connect(targetHost, targetPort, initialData) {
660
    const { username, password, hostname, port } = parsedSocks5Address;
661
    const socket = connect({ hostname, port }), writer = socket.writable.getWriter(), reader = socket.readable.getReader();
662
    try {
663
        const authMethods = username && password ? new Uint8Array([0x05, 0x02, 0x00, 0x02]) : new Uint8Array([0x05, 0x01, 0x00]);
664
        await writer.write(authMethods);
665
        let response = await reader.read();
666
        if (response.done || response.value.byteLength < 2) throw new Error('S5 method selection failed');
667

668
        const selectedMethod = new Uint8Array(response.value)[1];
669
        if (selectedMethod === 0x02) {
670
            if (!username || !password) throw new Error('S5 requires authentication');
671
            const userBytes = new TextEncoder().encode(username), passBytes = new TextEncoder().encode(password);
672
            const authPacket = new Uint8Array([0x01, userBytes.length, ...userBytes, passBytes.length, ...passBytes]);
673
            await writer.write(authPacket);
674
            response = await reader.read();
675
            if (response.done || new Uint8Array(response.value)[1] !== 0x00) throw new Error('S5 authentication failed');
676
        } else if (selectedMethod !== 0x00) throw new Error(`S5 unsupported auth method: ${selectedMethod}`);
677

678
        const hostBytes = new TextEncoder().encode(targetHost);
679
        const connectPacket = new Uint8Array([0x05, 0x01, 0x00, 0x03, hostBytes.length, ...hostBytes, targetPort >> 8, targetPort & 0xff]);
680
        await writer.write(connectPacket);
681
        response = await reader.read();
682
        if (response.done || new Uint8Array(response.value)[1] !== 0x00) throw new Error('S5 connection failed');
683

684
        await writer.write(initialData);
685
        writer.releaseLock(); reader.releaseLock();
686
        return socket;
687
    } catch (error) {
688
        try { writer.releaseLock(); } catch (e) { }
689
        try { reader.releaseLock(); } catch (e) { }
690
        try { socket.close(); } catch (e) { }
691
        throw error;
692
    }
693
}
694

695
async function httpConnect(targetHost, targetPort, initialData) {
696
    const { username, password, hostname, port } = parsedSocks5Address;
697
    const socket = connect({ hostname, port }), writer = socket.writable.getWriter(), reader = socket.readable.getReader();
698
    try {
699
        const auth = username && password ? `Proxy-Authorization: Basic ${btoa(`${username}:${password}`)}\r\n` : '';
700
        const request = `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r\nHost: ${targetHost}:${targetPort}\r\n${auth}User-Agent: Mozilla/5.0\r\nConnection: keep-alive\r\n\r\n`;
701
        await writer.write(new TextEncoder().encode(request));
702

703
        let responseBuffer = new Uint8Array(0), headerEndIndex = -1, bytesRead = 0;
704
        while (headerEndIndex === -1 && bytesRead < 8192) {
705
            const { done, value } = await reader.read();
706
            if (done) throw new Error('Connection closed before receiving HTTP response');
707
            responseBuffer = new Uint8Array([...responseBuffer, ...value]);
708
            bytesRead = responseBuffer.length;
709
            const crlfcrlf = responseBuffer.findIndex((_, i) => i < responseBuffer.length - 3 && responseBuffer[i] === 0x0d && responseBuffer[i + 1] === 0x0a && responseBuffer[i + 2] === 0x0d && responseBuffer[i + 3] === 0x0a);
710
            if (crlfcrlf !== -1) headerEndIndex = crlfcrlf + 4;
711
        }
712

713
        if (headerEndIndex === -1) throw new Error('Invalid HTTP response');
714
        const statusCode = parseInt(new TextDecoder().decode(responseBuffer.slice(0, headerEndIndex)).split('\r\n')[0].match(/HTTP\/\d\.\d\s+(\d+)/)[1]);
715
        if (statusCode < 200 || statusCode >= 300) throw new Error(`Connection failed: HTTP ${statusCode}`);
716

717
        await writer.write(initialData);
718
        writer.releaseLock(); reader.releaseLock();
719
        return socket;
720
    } catch (error) {
721
        try { writer.releaseLock(); } catch (e) { }
722
        try { reader.releaseLock(); } catch (e) { }
723
        try { socket.close(); } catch (e) { }
724
        throw error;
725
    }
726
}
727
//////////////////////////////////////////////////功能性函数///////////////////////////////////////////////
728
function surge(content, url, config_JSON) {
729
    const 每行内容 = content.includes('\r\n') ? content.split('\r\n') : content.split('\n');
730

731
    let 输出内容 = "";
732
    for (let x of 每行内容) {
733
        if (x.includes('= tro' + 'jan,')) {
734
            const host = x.split("sni=")[1].split(",")[0];
735
            const 备改内容 = `sni=${host}, skip-cert-verify=${config_JSON.跳过证书验证}`;
736
            const 正确内容 = `sni=${host}, skip-cert-verify=${config_JSON.跳过证书验证}, ws=true, ws-path=${config_JSON.PATH}, ws-headers=Host:"${host}"`;
737
            输出内容 += x.replace(new RegExp(备改内容, 'g'), 正确内容).replace("[", "").replace("]", "") + '\n';
738
        } else {
739
            输出内容 += x + '\n';
740
        }
741
    }
742

743
    输出内容 = `#!MANAGED-CONFIG ${url} interval=${config_JSON.优选订阅生成.SUBUpdateTime * 60 * 60} strict=false` + 输出内容.substring(输出内容.indexOf('\n'));
744
    return 输出内容;
745
}
746

747
async function 请求日志记录(env, request, 访问IP, 请求类型 = "Get_SUB", config_JSON) {
748
    const KV容量限制 = 4;//MB
749
    try {
750
        const 当前时间 = new Date();
751
        const 日志内容 = { TYPE: 请求类型, IP: 访问IP, ASN: `AS${request.cf.asn || '0'} ${request.cf.asOrganization || 'Unknown'}`, CC: `${request.cf.country || 'N/A'} ${request.cf.city || 'N/A'}`, URL: request.url, UA: request.headers.get('User-Agent') || 'Unknown', TIME: 当前时间.getTime() };
752
        let 日志数组 = [];
753
        const 现有日志 = await env.KV.get('log.json');
754
        if (现有日志) {
755
            try {
756
                日志数组 = JSON.parse(现有日志);
757
                if (!Array.isArray(日志数组)) { 日志数组 = [日志内容]; }
758
                else if (请求类型 !== "Get_SUB") {
759
                    const 三十分钟前时间戳 = 当前时间.getTime() - 30 * 60 * 1000;
760
                    if (日志数组.some(log => log.TYPE !== "Get_SUB" && log.IP === 访问IP && log.URL === request.url && log.UA === (request.headers.get('User-Agent') || 'Unknown') && log.TIME >= 三十分钟前时间戳)) return;
761
                    日志数组.push(日志内容);
762
                    while (JSON.stringify(日志数组, null, 2).length > KV容量限制 * 1024 * 1024 && 日志数组.length > 0) 日志数组.shift();
763
                } else {
764
                    日志数组.push(日志内容);
765
                    while (JSON.stringify(日志数组, null, 2).length > KV容量限制 * 1024 * 1024 && 日志数组.length > 0) 日志数组.shift();
766
                }
767
                if (config_JSON.TG.启用) {
768
                    try {
769
                        const TG_TXT = await env.KV.get('tg.json');
770
                        const TG_JSON = JSON.parse(TG_TXT);
771
                        await sendMessage(TG_JSON.BotToken, TG_JSON.ChatID, 日志内容, config_JSON);
772
                    } catch (error) { console.error(`读取tg.json出错: ${error.message}`) }
773
                }
774
            } catch (e) { 日志数组 = [日志内容]; }
775
        } else { 日志数组 = [日志内容]; }
776
        await env.KV.put('log.json', JSON.stringify(日志数组, null, 2));
777
    } catch (error) { console.error(`日志记录失败: ${error.message}`); }
778
}
779

780
async function sendMessage(BotToken, ChatID, 日志内容, config_JSON) {
781
    if (!BotToken || !ChatID) return;
782

783
    try {
784
        const 请求时间 = new Date(日志内容.TIME).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
785
        const 请求URL = new URL(日志内容.URL);
786
        const msg = `<b>#${config_JSON.优选订阅生成.SUBNAME} 日志通知</b>\n\n` +
787
            `📌 <b>类型：</b>#${日志内容.TYPE}\n` +
788
            `🌐 <b>IP：</b><code>${日志内容.IP}</code>\n` +
789
            `📍 <b>位置：</b>${日志内容.CC}\n` +
790
            `🏢 <b>ASN：</b>${日志内容.ASN}\n` +
791
            `🔗 <b>域名：</b><code>${请求URL.host}</code>\n` +
792
            `🔍 <b>路径：</b><code>${请求URL.pathname + 请求URL.search}</code>\n` +
793
            `🤖 <b>UA：</b><code>${日志内容.UA}</code>\n` +
794
            `📅 <b>时间：</b>${请求时间}\n` +
795
            `${config_JSON.CF.Usage.success ? `📊 <b>请求用量：</b>${config_JSON.CF.Usage.total}/100000 <b>${((config_JSON.CF.Usage.total / 100000) * 100).toFixed(2)}%</b>\n` : ''}`;
796

797
        const url = `https://api.telegram.org/bot${BotToken}/sendMessage?chat_id=${ChatID}&parse_mode=HTML&text=${encodeURIComponent(msg)}`;
798
        return fetch(url, {
799
            method: 'GET',
800
            headers: {
801
                'Accept': 'text/html,application/xhtml+xml,application/xml;',
802
                'Accept-Encoding': 'gzip, deflate, br',
803
                'User-Agent': 日志内容.UA || 'Unknown',
804
            }
805
        });
806
    } catch (error) { console.error('Error sending message:', error) }
807
}
808

809
function 掩码敏感信息(文本, 前缀长度 = 3, 后缀长度 = 2) {
810
    if (!文本 || typeof 文本 !== 'string') return 文本;
811
    if (文本.length <= 前缀长度 + 后缀长度) return 文本; // 如果长度太短，直接返回
812

813
    const 前缀 = 文本.slice(0, 前缀长度);
814
    const 后缀 = 文本.slice(-后缀长度);
815
    const 星号数量 = 文本.length - 前缀长度 - 后缀长度;
816

817
    return `${前缀}${'*'.repeat(星号数量)}${后缀}`;
818
}
819

820
async function MD5MD5(文本) {
821
    const 编码器 = new TextEncoder();
822

823
    const 第一次哈希 = await crypto.subtle.digest('MD5', 编码器.encode(文本));
824
    const 第一次哈希数组 = Array.from(new Uint8Array(第一次哈希));
825
    const 第一次十六进制 = 第一次哈希数组.map(字节 => 字节.toString(16).padStart(2, '0')).join('');
826

827
    const 第二次哈希 = await crypto.subtle.digest('MD5', 编码器.encode(第一次十六进制.slice(7, 27)));
828
    const 第二次哈希数组 = Array.from(new Uint8Array(第二次哈希));
829
    const 第二次十六进制 = 第二次哈希数组.map(字节 => 字节.toString(16).padStart(2, '0')).join('');
830

831
    return 第二次十六进制.toLowerCase();
832
}
833

834
function 随机路径() {
835
    const 常用路径目录 = ["#", "about", "account", "acg", "act", "activity", "ad", "admin", "ads", "ajax", "album", "albums", "anime", "api", "app", "apps", "archive", "archives", "article", "articles", "ask", "auth", "avatar", "bbs", "bd", "blog", "blogs", "book", "books", "bt", "buy", "cart", "category", "categories", "cb", "channel", "channels", "chat", "china", "city", "class", "classify", "clip", "clips", "club", "cn", "code", "collect", "collection", "comic", "comics", "community", "company", "config", "contact", "content", "course", "courses", "cp", "data", "detail", "details", "dh", "directory", "discount", "discuss", "dl", "dload", "doc", "docs", "document", "documents", "doujin", "download", "downloads", "drama", "edu", "en", "ep", "episode", "episodes", "event", "events", "f", "faq", "favorite", "favourites", "favs", "feedback", "file", "files", "film", "films", "forum", "forums", "friend", "friends", "game", "games", "gif", "go", "go.html", "go.php", "group", "groups", "help", "home", "hot", "htm", "html", "image", "images", "img", "index", "info", "intro", "item", "items", "ja", "jp", "jump", "jump.html", "jump.php", "jumping", "knowledge", "lang", "lesson", "lessons", "lib", "library", "link", "links", "list", "live", "lives", "login", "logout", "m", "mag", "magnet", "mall", "manhua", "map", "member", "members", "message", "messages", "mobile", "movie", "movies", "music", "my", "new", "news", "note", "novel", "novels", "online", "order", "out", "out.html", "out.php", "outbound", "p", "page", "pages", "pay", "payment", "pdf", "photo", "photos", "pic", "pics", "picture", "pictures", "play", "player", "playlist", "post", "posts", "product", "products", "program", "programs", "project", "qa", "question", "rank", "ranking", "read", "readme", "redirect", "redirect.html", "redirect.php", "reg", "register", "res", "resource", "retrieve", "sale", "search", "season", "seasons", "section", "seller", "series", "service", "services", "setting", "settings", "share", "shop", "show", "shows", "site", "soft", "sort", "source", "special", "star", "stars", "static", "stock", "store", "stream", "streaming", "streams", "student", "study", "tag", "tags", "task", "teacher", "team", "tech", "temp", "test", "thread", "tool", "tools", "topic", "topics", "torrent", "trade", "travel", "tv", "txt", "type", "u", "upload", "uploads", "url", "urls", "user", "users", "v", "version", "video", "videos", "view", "vip", "vod", "watch", "web", "wenku", "wiki", "work", "www", "zh", "zh-cn", "zh-tw", "zip"];
836
    const 随机数 = Math.floor(Math.random() * 3 + 1);
837
    const 随机路径 = 常用路径目录.sort(() => 0.5 - Math.random()).slice(0, 随机数).join('/');
838
    return `/${随机路径}`;
839
}
840

841
function 随机替换通配符(h) {
842
    if (!h?.includes('*')) return h;
843
    const 字符集 = 'abcdefghijklmnopqrstuvwxyz0123456789';
844
    return h.replace(/\*/g, () => {
845
        let s = '';
846
        for (let i = 0; i < Math.floor(Math.random() * 14) + 3; i++)
847
            s += 字符集[Math.floor(Math.random() * 36)];
848
        return s;
849
    });
850
}
851

852
function 批量替换域名(内容, hosts, 每组数量 = 2) {
853
    let count = 0, currentRandomHost = null;
854
    return 内容.replace(/example\.com/g, () => {
855
        if (count % 每组数量 === 0) currentRandomHost = 随机替换通配符(hosts[Math.floor(Math.random() * hosts.length)]);
856
        count++;
857
        return currentRandomHost;
858
    });
859
}
860

861
async function 读取config_JSON(env, hostname, userID, path, 重置配置 = false) {
862
    //const host = 随机替换通配符(hostname);
863
    const host = hostname;
864
    const 初始化开始时间 = performance.now();
865
    const 默认配置JSON = {
866
        TIME: new Date().toISOString(),
867
        HOST: host,
868
        HOSTS: [hostname],
869
        UUID: userID,
870
        协议类型: "v" + "le" + "ss",
871
        传输协议: "ws",
872
        跳过证书验证: true,
873
        启用0RTT: false,
874
        TLS分片: null,
875
        随机路径: false,
876
        优选订阅生成: {
877
            local: true, // true: 基于本地的优选地址  false: 优选订阅生成器
878
            本地IP库: {
879
                随机IP: true, // 当 随机IP 为true时生效，启用随机IP的数量，否则使用KV内的ADD.txt
880
                随机数量: 16,
881
                指定端口: -1,
882
            },
883
            SUB: null,
884
            SUBNAME: "edge" + "tunnel",
885
            SUBUpdateTime: 6, // 订阅更新时间（小时）
886
            TOKEN: await MD5MD5(hostname + userID),
887
        },
888
        订阅转换配置: {
889
            SUBAPI: "https://SUBAPI.cmliussss.net",
890
            SUBCONFIG: "https://raw.githubusercontent.com/cmliu/ACL4SSR/refs/heads/main/Clash/config/ACL4SSR_Online_Mini_MultiMode_CF.ini",
891
            SUBEMOJI: false,
892
        },
893
        反代: {
894
            PROXYIP: "auto",
895
            SOCKS5: {
896
                启用: 启用SOCKS5反代,
897
                全局: 启用SOCKS5全局反代,
898
                账号: 我的SOCKS5账号,
899
                白名单: SOCKS5白名单,
900
            },
901
        },
902
        TG: {
903
            启用: false,
904
            BotToken: null,
905
            ChatID: null,
906
        },
907
        CF: {
908
            Email: null,
909
            GlobalAPIKey: null,
910
            AccountID: null,
911
            APIToken: null,
912
            Usage: {
913
                success: false,
914
                pages: 0,
915
                workers: 0,
916
                total: 0,
917
            },
918
        }
919
    };
920

921
    try {
922
        let configJSON = await env.KV.get('config.json');
923
        if (!configJSON || 重置配置 == true) {
924
            await env.KV.put('config.json', JSON.stringify(默认配置JSON, null, 2));
925
            config_JSON = 默认配置JSON;
926
        } else {
927
            config_JSON = JSON.parse(configJSON);
928
        }
929
    } catch (error) {
930
        console.error(`读取config_JSON出错: ${error.message}`);
931
        config_JSON = 默认配置JSON;
932
    }
933

934
    config_JSON.HOST = host;
935
    if (!config_JSON.HOSTS) config_JSON.HOSTS = [hostname];
936
    if (env.HOST) config_JSON.HOSTS = (await 整理成数组(env.HOST)).map(h => h.toLowerCase().replace(/^https?:\/\//, '').split('/')[0].split(':')[0]);
937
    config_JSON.UUID = userID;
938
    config_JSON.PATH = path ? (path.startsWith('/') ? path : '/' + path) : (config_JSON.反代.SOCKS5.启用 ? ('/' + config_JSON.反代.SOCKS5.启用 + (config_JSON.反代.SOCKS5.全局 ? '://' : '=') + config_JSON.反代.SOCKS5.账号) : (config_JSON.反代.PROXYIP === 'auto' ? '/' : `/proxyip=${config_JSON.反代.PROXYIP}`));
939
    const TLS分片参数 = config_JSON.TLS分片 == 'Shadowrocket' ? `&fragment=${encodeURIComponent('1,40-60,30-50,tlshello')}` : config_JSON.TLS分片 == 'Happ' ? `&fragment=${encodeURIComponent('3,1,tlshello')}` : '';
940
    config_JSON.LINK = `${config_JSON.协议类型}://${userID}@${host}:443?security=tls&type=${config_JSON.传输协议}&host=${host}&sni=${host}&path=${encodeURIComponent(config_JSON.启用0RTT ? config_JSON.PATH + '?ed=2560' : config_JSON.PATH) + TLS分片参数}&encryption=none${config_JSON.跳过证书验证 ? '&allowInsecure=1' : ''}#${encodeURIComponent(config_JSON.优选订阅生成.SUBNAME)}`;
941
    config_JSON.优选订阅生成.TOKEN = await MD5MD5(hostname + userID);
942

943
    const 初始化TG_JSON = { BotToken: null, ChatID: null };
944
    config_JSON.TG = { 启用: config_JSON.TG.启用 ? config_JSON.TG.启用 : false, ...初始化TG_JSON };
945
    try {
946
        const TG_TXT = await env.KV.get('tg.json');
947
        if (!TG_TXT) {
948
            await env.KV.put('tg.json', JSON.stringify(初始化TG_JSON, null, 2));
949
        } else {
950
            const TG_JSON = JSON.parse(TG_TXT);
951
            config_JSON.TG.ChatID = TG_JSON.ChatID ? TG_JSON.ChatID : null;
952
            config_JSON.TG.BotToken = TG_JSON.BotToken ? 掩码敏感信息(TG_JSON.BotToken) : null;
953
        }
954
    } catch (error) {
955
        console.error(`读取tg.json出错: ${error.message}`);
956
    }
957

958
    const 初始化CF_JSON = { Email: null, GlobalAPIKey: null, AccountID: null, APIToken: null };
959
    config_JSON.CF = { ...初始化CF_JSON, Usage: { success: false, pages: 0, workers: 0, total: 0 } };
960
    try {
961
        const CF_TXT = await env.KV.get('cf.json');
962
        if (!CF_TXT) {
963
            await env.KV.put('cf.json', JSON.stringify(初始化CF_JSON, null, 2));
964
        } else {
965
            const CF_JSON = JSON.parse(CF_TXT);
966
            config_JSON.CF.Email = CF_JSON.Email ? CF_JSON.Email : null;
967
            config_JSON.CF.GlobalAPIKey = CF_JSON.GlobalAPIKey ? 掩码敏感信息(CF_JSON.GlobalAPIKey) : null;
968
            config_JSON.CF.AccountID = CF_JSON.AccountID ? 掩码敏感信息(CF_JSON.AccountID) : null;
969
            config_JSON.CF.APIToken = CF_JSON.APIToken ? 掩码敏感信息(CF_JSON.APIToken) : null;
970
            const Usage = await getCloudflareUsage(CF_JSON.Email, CF_JSON.GlobalAPIKey, CF_JSON.AccountID, CF_JSON.APIToken);
971
            config_JSON.CF.Usage = Usage;
972
        }
973
    } catch (error) {
974
        console.error(`读取cf.json出错: ${error.message}`);
975
    }
976

977
    config_JSON.加载时间 = (performance.now() - 初始化开始时间).toFixed(2) + 'ms';
978
    return config_JSON;
979
}
980

981
async function 生成随机IP(request, count = 16, 指定端口 = -1) {
982
    const asnMap = { '9808': 'cmcc', '4837': 'cu', '4134': 'ct' }, asn = request.cf.asn;
983
    const cidr_url = asnMap[asn] ? `https://raw.githubusercontent.com/cmliu/cmliu/main/CF-CIDR/${asnMap[asn]}.txt` : 'https://raw.githubusercontent.com/cmliu/cmliu/main/CF-CIDR.txt';
984
    const cfname = { '9808': 'CF移动优选', '4837': 'CF联通优选', '4134': 'CF电信优选' }[asn] || 'CF官方优选';
985
    const cfport = [443, 2053, 2083, 2087, 2096, 8443];
986
    let cidrList = [];
987
    try { const res = await fetch(cidr_url); cidrList = res.ok ? await 整理成数组(await res.text()) : ['104.16.0.0/13']; } catch { cidrList = ['104.16.0.0/13']; }
988

989
    const generateRandomIPFromCIDR = (cidr) => {
990
        const [baseIP, prefixLength] = cidr.split('/'), prefix = parseInt(prefixLength), hostBits = 32 - prefix;
991
        const ipInt = baseIP.split('.').reduce((a, p, i) => a | (parseInt(p) << (24 - i * 8)), 0);
992
        const randomOffset = Math.floor(Math.random() * Math.pow(2, hostBits));
993
        const mask = (0xFFFFFFFF << hostBits) >>> 0, randomIP = (((ipInt & mask) >>> 0) + randomOffset) >>> 0;
994
        return [(randomIP >>> 24) & 0xFF, (randomIP >>> 16) & 0xFF, (randomIP >>> 8) & 0xFF, randomIP & 0xFF].join('.');
995
    };
996

997
    const randomIPs = Array.from({ length: count }, () => {
998
        const ip = generateRandomIPFromCIDR(cidrList[Math.floor(Math.random() * cidrList.length)]);
999
        return `${ip}:${指定端口 === -1 ? cfport[Math.floor(Math.random() * cfport.length)] : 指定端口}#${cfname}`;
1000
    });
1001
    return [randomIPs, randomIPs.join('\n')];
1002
}
1003
async function 整理成数组(内容) {
1004
    var 替换后的内容 = 内容.replace(/[  "'\r\n]+/g, ',').replace(/,+/g, ',');
1005
    if (替换后的内容.charAt(0) == ',') 替换后的内容 = 替换后的内容.slice(1);
1006
    if (替换后的内容.charAt(替换后的内容.length - 1) == ',') 替换后的内容 = 替换后的内容.slice(0, 替换后的内容.length - 1);
1007
    const 地址数组 = 替换后的内容.split(',');
1008
    return 地址数组;
1009
}
1010

1011
async function 请求优选API(urls, 默认端口 = '443', 超时时间 = 3000) {
1012
    if (!urls?.length) return [];
1013
    const results = new Set();
1014
    await Promise.allSettled(urls.map(async (url) => {
1015
        try {
1016
            const controller = new AbortController();
1017
            const timeoutId = setTimeout(() => controller.abort(), 超时时间);
1018
            const response = await fetch(url, { signal: controller.signal });
1019
            clearTimeout(timeoutId);
1020
            let text = '';
1021
            try {
1022
                const buffer = await response.arrayBuffer();
1023
                const contentType = (response.headers.get('content-type') || '').toLowerCase();
1024
                const charset = contentType.match(/charset=([^\s;]+)/i)?.[1]?.toLowerCase() || '';
1025

1026
                // 根据 Content-Type 响应头判断编码优先级
1027
                let decoders = ['utf-8', 'gb2312']; // 默认优先 UTF-8
1028
                if (charset.includes('gb') || charset.includes('gbk') || charset.includes('gb2312')) {
1029
                    decoders = ['gb2312', 'utf-8']; // 如果明确指定 GB 系编码，优先尝试 GB2312
1030
                }
1031

1032
                // 尝试多种编码解码
1033
                let decodeSuccess = false;
1034
                for (const decoder of decoders) {
1035
                    try {
1036
                        const decoded = new TextDecoder(decoder).decode(buffer);
1037
                        // 验证解码结果的有效性
1038
                        if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
1039
                            text = decoded;
1040
                            decodeSuccess = true;
1041
                            break;
1042
                        } else if (decoded && decoded.length > 0) {
1043
                            // 如果有替换字符 (U+FFFD)，说明编码不匹配，继续尝试下一个编码
1044
                            continue;
1045
                        }
1046
                    } catch (e) {
1047
                        // 该编码解码失败，尝试下一个
1048
                        continue;
1049
                    }
1050
                }
1051

1052
                // 如果所有编码都失败或无效，尝试 response.text()
1053
                if (!decodeSuccess) {
1054
                    text = await response.text();
1055
                }
1056

1057
                // 如果返回的是空或无效数据，返回
1058
                if (!text || text.trim().length === 0) {
1059
                    return;
1060
                }
1061
            } catch (e) {
1062
                console.error('Failed to decode response:', e);
1063
                return;
1064
            }
1065
            const lines = text.trim().split('\n').map(l => l.trim()).filter(l => l);
1066
            const isCSV = lines.length > 1 && lines[0].includes(',');
1067
            const IPV6_PATTERN = /^[^\[\]]*:[^\[\]]*:[^\[\]]/;
1068
            if (!isCSV) {
1069
                lines.forEach(line => {
1070
                    const hashIndex = line.indexOf('#');
1071
                    const [hostPart, remark] = hashIndex > -1 ? [line.substring(0, hashIndex), line.substring(hashIndex)] : [line, ''];
1072
                    let hasPort = false;
1073
                    if (hostPart.startsWith('[')) {
1074
                        hasPort = /\]:(\d+)$/.test(hostPart);
1075
                    } else {
1076
                        const colonIndex = hostPart.lastIndexOf(':');
1077
                        hasPort = colonIndex > -1 && /^\d+$/.test(hostPart.substring(colonIndex + 1));
1078
                    }
1079
                    const port = new URL(url).searchParams.get('port') || 默认端口;
1080
                    results.add(hasPort ? line : `${hostPart}:${port}${remark}`);
1081
                });
1082
            } else {
1083
                const headers = lines[0].split(',').map(h => h.trim());
1084
                const dataLines = lines.slice(1);
1085
                if (headers.includes('IP地址') && headers.includes('端口') && headers.includes('数据中心')) {
1086
                    const ipIdx = headers.indexOf('IP地址'), portIdx = headers.indexOf('端口');
1087
                    const remarkIdx = headers.indexOf('国家') > -1 ? headers.indexOf('国家') :
1088
                        headers.indexOf('城市') > -1 ? headers.indexOf('城市') : headers.indexOf('数据中心');
1089
                    const tlsIdx = headers.indexOf('TLS');
1090
                    dataLines.forEach(line => {
1091
                        const cols = line.split(',').map(c => c.trim());
1092
                        if (tlsIdx !== -1 && cols[tlsIdx]?.toLowerCase() !== 'true') return;
1093
                        const wrappedIP = IPV6_PATTERN.test(cols[ipIdx]) ? `[${cols[ipIdx]}]` : cols[ipIdx];
1094
                        results.add(`${wrappedIP}:${cols[portIdx]}#${cols[remarkIdx]}`);
1095
                    });
1096
                } else if (headers.some(h => h.includes('IP')) && headers.some(h => h.includes('延迟')) && headers.some(h => h.includes('下载速度'))) {
1097
                    const ipIdx = headers.findIndex(h => h.includes('IP'));
1098
                    const delayIdx = headers.findIndex(h => h.includes('延迟'));
1099
                    const speedIdx = headers.findIndex(h => h.includes('下载速度'));
1100
                    const port = new URL(url).searchParams.get('port') || 默认端口;
1101
                    dataLines.forEach(line => {
1102
                        const cols = line.split(',').map(c => c.trim());
1103
                        const wrappedIP = IPV6_PATTERN.test(cols[ipIdx]) ? `[${cols[ipIdx]}]` : cols[ipIdx];
1104
                        results.add(`${wrappedIP}:${port}#CF优选 ${cols[delayIdx]}ms ${cols[speedIdx]}MB/s`);
1105
                    });
1106
                }
1107
            }
1108
        } catch (e) { }
1109
    }));
1110
    return Array.from(results);
1111
}
1112

1113
async function 反代参数获取(request) {
1114
    const url = new URL(request.url);
1115
    const { pathname, searchParams } = url;
1116
    const pathLower = pathname.toLowerCase();
1117

1118
    // 初始化
1119
    我的SOCKS5账号 = searchParams.get('socks5') || searchParams.get('http') || null;
1120
    启用SOCKS5全局反代 = searchParams.has('globalproxy') || false;
1121

1122
    // 统一处理反代IP参数 (优先级最高,使用正则一次匹配)
1123
    const proxyMatch = pathLower.match(/\/(proxyip[.=]|pyip=|ip=)(.+)/);
1124
    if (searchParams.has('proxyip')) {
1125
        const 路参IP = searchParams.get('proxyip');
1126
        反代IP = 路参IP.includes(',') ? 路参IP.split(',')[Math.floor(Math.random() * 路参IP.split(',').length)] : 路参IP;
1127
        return;
1128
    } else if (proxyMatch) {
1129
        const 路参IP = proxyMatch[1] === 'proxyip.' ? `proxyip.${proxyMatch[2]}` : proxyMatch[2];
1130
        反代IP = 路参IP.includes(',') ? 路参IP.split(',')[Math.floor(Math.random() * 路参IP.split(',').length)] : 路参IP;
1131
        return;
1132
    }
1133

1134
    // 处理SOCKS5/HTTP代理参数
1135
    let socksMatch;
1136
    if ((socksMatch = pathname.match(/\/(socks5?|http):\/?\/?(.+)/i))) {
1137
        // 格式: /socks5://... 或 /http://...
1138
        启用SOCKS5反代 = socksMatch[1].toLowerCase() === 'http' ? 'http' : 'socks5';
1139
        我的SOCKS5账号 = socksMatch[2].split('#')[0];
1140
        启用SOCKS5全局反代 = true;
1141

1142
        // 处理Base64编码的用户名密码
1143
        if (我的SOCKS5账号.includes('@')) {
1144
            const atIndex = 我的SOCKS5账号.lastIndexOf('@');
1145
            let userPassword = 我的SOCKS5账号.substring(0, atIndex).replaceAll('%3D', '=');
1146
            if (/^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i.test(userPassword) && !userPassword.includes(':')) {
1147
                userPassword = atob(userPassword);
1148
            }
1149
            我的SOCKS5账号 = `${userPassword}@${我的SOCKS5账号.substring(atIndex + 1)}`;
1150
        }
1151
    } else if ((socksMatch = pathname.match(/\/(g?s5|socks5|g?http)=(.+)/i))) {
1152
        // 格式: /socks5=... 或 /s5=... 或 /gs5=... 或 /http=... 或 /ghttp=...
1153
        const type = socksMatch[1].toLowerCase();
1154
        我的SOCKS5账号 = socksMatch[2];
1155
        启用SOCKS5反代 = type.includes('http') ? 'http' : 'socks5';
1156
        启用SOCKS5全局反代 = type.startsWith('g') || 启用SOCKS5全局反代; // gs5 或 ghttp 开头启用全局
1157
    }
1158

1159
    // 解析SOCKS5地址
1160
    if (我的SOCKS5账号) {
1161
        try {
1162
            parsedSocks5Address = await 获取SOCKS5账号(我的SOCKS5账号);
1163
            启用SOCKS5反代 = searchParams.get('http') ? 'http' : 启用SOCKS5反代;
1164
        } catch (err) {
1165
            console.error('解析SOCKS5地址失败:', err.message);
1166
            启用SOCKS5反代 = null;
1167
        }
1168
    } else 启用SOCKS5反代 = null;
1169
}
1170

1171
async function 获取SOCKS5账号(address) {
1172
    if (address.includes('@')) {
1173
        const lastAtIndex = address.lastIndexOf('@');
1174
        let userPassword = address.substring(0, lastAtIndex).replaceAll('%3D', '=');
1175
        const base64Regex = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i;
1176
        if (base64Regex.test(userPassword) && !userPassword.includes(':')) userPassword = atob(userPassword);
1177
        address = `${userPassword}@${address.substring(lastAtIndex + 1)}`;
1178
    }
1179
    const atIndex = address.lastIndexOf("@");
1180
    const [hostPart, authPart] = atIndex === -1 ? [address, undefined] : [address.substring(atIndex + 1), address.substring(0, atIndex)];
1181

1182
    // 解析认证
1183
    let username, password;
1184
    if (authPart) {
1185
        [username, password] = authPart.split(":");
1186
        if (!password) throw new Error('无效的 SOCKS 地址格式：认证部分必须是 "username:password" 的形式');
1187
    }
1188

1189
    // 解析主机端口
1190
    let hostname, port;
1191
    if (hostPart.includes("]:")) { // IPv6带端口
1192
        [hostname, port] = [hostPart.split("]:")[0] + "]", Number(hostPart.split("]:")[1].replace(/[^\d]/g, ''))];
1193
    } else if (hostPart.startsWith("[")) { // IPv6无端口
1194
        [hostname, port] = [hostPart, 80];
1195
    } else { // IPv4/域名
1196
        const parts = hostPart.split(":");
1197
        [hostname, port] = parts.length === 2 ? [parts[0], Number(parts[1].replace(/[^\d]/g, ''))] : [hostPart, 80];
1198
    }
1199

1200
    if (isNaN(port)) throw new Error('无效的 SOCKS 地址格式：端口号必须是数字');
1201
    if (hostname.includes(":") && !/^\[.*\]$/.test(hostname)) throw new Error('无效的 SOCKS 地址格式：IPv6 地址必须用方括号括起来，如 [2001:db8::1]');
1202

1203
    return { username, password, hostname, port };
1204
}
1205

1206
async function getCloudflareUsage(Email, GlobalAPIKey, AccountID, APIToken) {
1207
    const API = "https://api.cloudflare.com/client/v4";
1208
    const sum = (a) => a?.reduce((t, i) => t + (i?.sum?.requests || 0), 0) || 0;
1209
    const cfg = { "Content-Type": "application/json" };
1210

1211
    try {
1212
        if (!AccountID && (!Email || !GlobalAPIKey)) return { success: false, pages: 0, workers: 0, total: 0 };
1213

1214
        if (!AccountID) {
1215
            const r = await fetch(`${API}/accounts`, {
1216
                method: "GET",
1217
                headers: { ...cfg, "X-AUTH-EMAIL": Email, "X-AUTH-KEY": GlobalAPIKey }
1218
            });
1219
            if (!r.ok) throw new Error(`账户获取失败: ${r.status}`);
1220
            const d = await r.json();
1221
            if (!d?.result?.length) throw new Error("未找到账户");
1222
            const idx = d.result.findIndex(a => a.name?.toLowerCase().startsWith(Email.toLowerCase()));
1223
            AccountID = d.result[idx >= 0 ? idx : 0]?.id;
1224
        }
1225

1226
        const now = new Date();
1227
        now.setUTCHours(0, 0, 0, 0);
1228
        const hdr = APIToken ? { ...cfg, "Authorization": `Bearer ${APIToken}` } : { ...cfg, "X-AUTH-EMAIL": Email, "X-AUTH-KEY": GlobalAPIKey };
1229

1230
        const res = await fetch(`${API}/graphql`, {
1231
            method: "POST",
1232
            headers: hdr,
1233
            body: JSON.stringify({
1234
                query: `query getBillingMetrics($AccountID: String!, $filter: AccountWorkersInvocationsAdaptiveFilter_InputObject) {
1235
                    viewer { accounts(filter: {accountTag: $AccountID}) {
1236
                        pagesFunctionsInvocationsAdaptiveGroups(limit: 1000, filter: $filter) { sum { requests } }
1237
                        workersInvocationsAdaptive(limit: 10000, filter: $filter) { sum { requests } }
1238
                    } }
1239
                }`,
1240
                variables: { AccountID, filter: { datetime_geq: now.toISOString(), datetime_leq: new Date().toISOString() } }
1241
            })
1242
        });
1243

1244
        if (!res.ok) throw new Error(`查询失败: ${res.status}`);
1245
        const result = await res.json();
1246
        if (result.errors?.length) throw new Error(result.errors[0].message);
1247

1248
        const acc = result?.data?.viewer?.accounts?.[0];
1249
        if (!acc) throw new Error("未找到账户数据");
1250

1251
        const pages = sum(acc.pagesFunctionsInvocationsAdaptiveGroups);
1252
        const workers = sum(acc.workersInvocationsAdaptive);
1253
        const total = pages + workers;
1254
        console.log(`统计结果 - Pages: ${pages}, Workers: ${workers}, 总计: ${total}`);
1255
        return { success: true, pages, workers, total };
1256

1257
    } catch (error) {
1258
        console.error('获取使用量错误:', error.message);
1259
        return { success: false, pages: 0, workers: 0, total: 0 };
1260
    }
1261
}
1262

1263
function sha224(s) {
1264
    const K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
1265
    const r = (n, b) => ((n >>> b) | (n << (32 - b))) >>> 0;
1266
    s = unescape(encodeURIComponent(s));
1267
    const l = s.length * 8; s += String.fromCharCode(0x80);
1268
    while ((s.length * 8) % 512 !== 448) s += String.fromCharCode(0);
1269
    const h = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
1270
    const hi = Math.floor(l / 0x100000000), lo = l & 0xFFFFFFFF;
1271
    s += String.fromCharCode((hi >>> 24) & 0xFF, (hi >>> 16) & 0xFF, (hi >>> 8) & 0xFF, hi & 0xFF, (lo >>> 24) & 0xFF, (lo >>> 16) & 0xFF, (lo >>> 8) & 0xFF, lo & 0xFF);
1272
    const w = []; for (let i = 0; i < s.length; i += 4)w.push((s.charCodeAt(i) << 24) | (s.charCodeAt(i + 1) << 16) | (s.charCodeAt(i + 2) << 8) | s.charCodeAt(i + 3));
1273
    for (let i = 0; i < w.length; i += 16) {
1274
        const x = new Array(64).fill(0);
1275
        for (let j = 0; j < 16; j++)x[j] = w[i + j];
1276
        for (let j = 16; j < 64; j++) {
1277
            const s0 = r(x[j - 15], 7) ^ r(x[j - 15], 18) ^ (x[j - 15] >>> 3);
1278
            const s1 = r(x[j - 2], 17) ^ r(x[j - 2], 19) ^ (x[j - 2] >>> 10);
1279
            x[j] = (x[j - 16] + s0 + x[j - 7] + s1) >>> 0;
1280
        }
1281
        let [a, b, c, d, e, f, g, h0] = h;
1282
        for (let j = 0; j < 64; j++) {
1283
            const S1 = r(e, 6) ^ r(e, 11) ^ r(e, 25), ch = (e & f) ^ (~e & g), t1 = (h0 + S1 + ch + K[j] + x[j]) >>> 0;
1284
            const S0 = r(a, 2) ^ r(a, 13) ^ r(a, 22), maj = (a & b) ^ (a & c) ^ (b & c), t2 = (S0 + maj) >>> 0;
1285
            h0 = g; g = f; f = e; e = (d + t1) >>> 0; d = c; c = b; b = a; a = (t1 + t2) >>> 0;
1286
        }
1287
        for (let j = 0; j < 8; j++)h[j] = (h[j] + (j === 0 ? a : j === 1 ? b : j === 2 ? c : j === 3 ? d : j === 4 ? e : j === 5 ? f : j === 6 ? g : h0)) >>> 0;
1288
    }
1289
    let hex = '';
1290
    for (let i = 0; i < 7; i++) {
1291
        for (let j = 24; j >= 0; j -= 8)hex += ((h[i] >>> j) & 0xFF).toString(16).padStart(2, '0');
1292
    }
1293
    return hex;
1294
}
1295

1296
async function 解析地址端口(proxyIP) {
1297
    proxyIP = proxyIP.toLowerCase();
1298
    if (proxyIP.includes('.william')) {
1299
        const williamResult = await (async function 解析William域名(william) {
1300
            try {
1301
                const response = await fetch(`https://1.1.1.1/dns-query?name=${william}&type=TXT`, { headers: { 'Accept': 'application/dns-json' } });
1302
                if (!response.ok) return null;
1303
                const data = await response.json();
1304
                const txtRecords = (data.Answer || []).filter(record => record.type === 16).map(record => record.data);
1305
                if (txtRecords.length === 0) return null;
1306
                let txtData = txtRecords[0];
1307
                if (txtData.startsWith('"') && txtData.endsWith('"')) txtData = txtData.slice(1, -1);
1308
                const prefixes = txtData.replace(/\\010/g, ',').replace(/\n/g, ',').split(',').map(s => s.trim()).filter(Boolean);
1309
                if (prefixes.length === 0) return null;
1310
                return prefixes[Math.floor(Math.random() * prefixes.length)];
1311
            } catch (error) {
1312
                console.error('解析ProxyIP失败:', error);
1313
                return null;
1314
            }
1315
        })(proxyIP);
1316
        proxyIP = williamResult || proxyIP;
1317
    }
1318
    let 地址 = proxyIP, 端口 = 443;
1319
    if (proxyIP.includes('.tp')) {
1320
        const tpMatch = proxyIP.match(/\.tp(\d+)/);
1321
        if (tpMatch) 端口 = parseInt(tpMatch[1], 10);
1322
        return [地址, 端口];
1323
    }
1324
    if (proxyIP.includes(']:')) {
1325
        const parts = proxyIP.split(']:');
1326
        地址 = parts[0] + ']';
1327
        端口 = parseInt(parts[1], 10) || 端口;
1328
    } else if (proxyIP.includes(':') && !proxyIP.startsWith('[')) {
1329
        const colonIndex = proxyIP.lastIndexOf(':');
1330
        地址 = proxyIP.slice(0, colonIndex);
1331
        端口 = parseInt(proxyIP.slice(colonIndex + 1), 10) || 端口;
1332
    }
1333
    return [地址, 端口];
1334
}
1335

1336
async function SOCKS5可用性验证(代理协议 = 'socks5', 代理参数) {
1337
    const startTime = Date.now();
1338
    try { parsedSocks5Address = await 获取SOCKS5账号(代理参数); } catch (err) { return { success: false, error: err.message, proxy: 代理协议 + "://" + 代理参数, responseTime: Date.now() - startTime }; }
1339
    const { username, password, hostname, port } = parsedSocks5Address;
1340
    const 完整代理参数 = username && password ? `${username}:${password}@${hostname}:${port}` : `${hostname}:${port}`;
1341
    try {
1342
        const initialData = new Uint8Array(0);
1343
        const tcpSocket = 代理协议 == 'socks5' ? await socks5Connect('check.socks5.090227.xyz', 80, initialData) : await httpConnect('check.socks5.090227.xyz', 80, initialData);
1344
        if (!tcpSocket) return { success: false, error: '无法连接到代理服务器', proxy: 代理协议 + "://" + 完整代理参数, responseTime: Date.now() - startTime };
1345
        try {
1346
            const writer = tcpSocket.writable.getWriter(), encoder = new TextEncoder();
1347
            await writer.write(encoder.encode(`GET /cdn-cgi/trace HTTP/1.1\r\nHost: check.socks5.090227.xyz\r\nConnection: close\r\n\r\n`));
1348
            writer.releaseLock();
1349
            const reader = tcpSocket.readable.getReader(), decoder = new TextDecoder();
1350
            let response = '';
1351
            try { while (true) { const { done, value } = await reader.read(); if (done) break; response += decoder.decode(value, { stream: true }); } } finally { reader.releaseLock(); }
1352
            await tcpSocket.close();
1353
            return { success: true, proxy: 代理协议 + "://" + 完整代理参数, ip: response.match(/ip=(.*)/)[1], loc: response.match(/loc=(.*)/)[1], responseTime: Date.now() - startTime };
1354
        } catch (error) {
1355
            try { await tcpSocket.close(); } catch (e) { console.log('关闭连接时出错:', e); }
1356
            return { success: false, error: error.message, proxy: 代理协议 + "://" + 完整代理参数, responseTime: Date.now() - startTime };
1357
        }
1358
    } catch (error) { return { success: false, error: error.message, proxy: 代理协议 + "://" + 完整代理参数, responseTime: Date.now() - startTime }; }
1359
}
1360
//////////////////////////////////////////////////////HTML伪装页面///////////////////////////////////////////////
1361
async function nginx() {
1362
    return `
1363
  <!DOCTYPE html>
1364
  <html>
1365
  <head>
1366
  <title>Welcome to nginx!</title>
1367
  <style>
1368
    body {
1369
      width: 35em;
1370
      margin: 0 auto;
1371
      font-family: Tahoma, Verdana, Arial, sans-serif;
1372
    }
1373
  </style>
1374
  </head>
1375
  <body>
1376
  <h1>Welcome to nginx!</h1>
1377
  <p>If you see this page, the nginx web server is successfully installed and
1378
  working. Further configuration is required.</p>
1379

1380
  <p>For online documentation and support please refer to
1381
  <a href="http://nginx.org/">nginx.org</a>.<br/>
1382
  Commercial support is available at
1383
  <a href="http://nginx.com/">nginx.com</a>.</p>
1384

1385
  <p><em>Thank you for using nginx.</em></p>
1386
  </body>
1387
  </html>
1388
  `
1389
}
1390

1391
async function html1101(host, 访问IP) {
1392
    const now = new Date();
1393
    const 格式化时间戳 = now.getFullYear() + '-' + String(now.getMonth() + 1).padStart(2, '0') + '-' + String(now.getDate()).padStart(2, '0') + ' ' + String(now.getHours()).padStart(2, '0') + ':' + String(now.getMinutes()).padStart(2, '0') + ':' + String(now.getSeconds()).padStart(2, '0');
1394
    const 随机字符串 = Array.from(crypto.getRandomValues(new Uint8Array(8))).map(b => b.toString(16).padStart(2, '0')).join('');
1395

1396
    return `<!DOCTYPE html>
1397
<!--[if lt IE 7]> <html class="no-js ie6 oldie" lang="en-US"> <![endif]-->
1398
<!--[if IE 7]>    <html class="no-js ie7 oldie" lang="en-US"> <![endif]-->
1399
<!--[if IE 8]>    <html class="no-js ie8 oldie" lang="en-US"> <![endif]-->
1400
<!--[if gt IE 8]><!--> <html class="no-js" lang="en-US"> <!--<![endif]-->
1401
<head>
1402
<title>Worker threw exception | ${host} | Cloudflare</title>
1403
<meta charset="UTF-8" />
1404
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
1405
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
1406
<meta name="robots" content="noindex, nofollow" />
1407
<meta name="viewport" content="width=device-width,initial-scale=1" />
1408
<link rel="stylesheet" id="cf_styles-css" href="/cdn-cgi/styles/cf.errors.css" />
1409
<!--[if lt IE 9]><link rel="stylesheet" id='cf_styles-ie-css' href="/cdn-cgi/styles/cf.errors.ie.css" /><![endif]-->
1410
<style>body{margin:0;padding:0}</style>
1411

1412

1413
<!--[if gte IE 10]><!-->
1414
<script>
1415
  if (!navigator.cookieEnabled) {
1416
    window.addEventListener('DOMContentLoaded', function () {
1417
      var cookieEl = document.getElementById('cookie-alert');
1418
      cookieEl.style.display = 'block';
1419
    })
1420
  }
1421
</script>
1422
<!--<![endif]-->
1423

1424
</head>
1425
<body>
1426
    <div id="cf-wrapper">
1427
        <div class="cf-alert cf-alert-error cf-cookie-error" id="cookie-alert" data-translate="enable_cookies">Please enable cookies.</div>
1428
        <div id="cf-error-details" class="cf-error-details-wrapper">
1429
            <div class="cf-wrapper cf-header cf-error-overview">
1430
                <h1>
1431
                    <span class="cf-error-type" data-translate="error">Error</span>
1432
                    <span class="cf-error-code">1101</span>
1433
                    <small class="heading-ray-id">Ray ID: ${随机字符串} &bull; ${格式化时间戳} UTC</small>
1434
                </h1>
1435
                <h2 class="cf-subheadline" data-translate="error_desc">Worker threw exception</h2>
1436
            </div><!-- /.header -->
1437

1438
            <section></section><!-- spacer -->
1439

1440
            <div class="cf-section cf-wrapper">
1441
                <div class="cf-columns two">
1442
                    <div class="cf-column">
1443
                        <h2 data-translate="what_happened">What happened?</h2>
1444
                            <p>You've requested a page on a website (${host}) that is on the <a href="https://www.cloudflare.com/5xx-error-landing?utm_source=error_100x" target="_blank">Cloudflare</a> network. An unknown error occurred while rendering the page.</p>
1445
                    </div>
1446

1447
                    <div class="cf-column">
1448
                        <h2 data-translate="what_can_i_do">What can I do?</h2>
1449
                            <p><strong>If you are the owner of this website:</strong><br />refer to <a href="https://developers.cloudflare.com/workers/observability/errors/" target="_blank">Workers - Errors and Exceptions</a> and check Workers Logs for ${host}.</p>
1450
                    </div>
1451

1452
                </div>
1453
            </div><!-- /.section -->
1454

1455
            <div class="cf-error-footer cf-wrapper w-240 lg:w-full py-10 sm:py-4 sm:px-8 mx-auto text-center sm:text-left border-solid border-0 border-t border-gray-300">
1456
    <p class="text-13">
1457
      <span class="cf-footer-item sm:block sm:mb-1">Cloudflare Ray ID: <strong class="font-semibold"> ${随机字符串}</strong></span>
1458
      <span class="cf-footer-separator sm:hidden">&bull;</span>
1459
      <span id="cf-footer-item-ip" class="cf-footer-item hidden sm:block sm:mb-1">
1460
        Your IP:
1461
        <button type="button" id="cf-footer-ip-reveal" class="cf-footer-ip-reveal-btn">Click to reveal</button>
1462
        <span class="hidden" id="cf-footer-ip">${访问IP}</span>
1463
        <span class="cf-footer-separator sm:hidden">&bull;</span>
1464
      </span>
1465
      <span class="cf-footer-item sm:block sm:mb-1"><span>Performance &amp; security by</span> <a rel="noopener noreferrer" href="https://www.cloudflare.com/5xx-error-landing" id="brand_link" target="_blank">Cloudflare</a></span>
1466

1467
    </p>
1468
    <script>(function(){function d(){var b=a.getElementById("cf-footer-item-ip"),c=a.getElementById("cf-footer-ip-reveal");b&&"classList"in b&&(b.classList.remove("hidden"),c.addEventListener("click",function(){c.classList.add("hidden");a.getElementById("cf-footer-ip").classList.remove("hidden")}))}var a=document;document.addEventListener&&a.addEventListener("DOMContentLoaded",d)})();</script>
1469
  </div><!-- /.error-footer -->
1470

1471
        </div><!-- /#cf-error-details -->
1472
    </div><!-- /#cf-wrapper -->
1473

1474
     <script>
1475
    window._cf_translation = {};
1476

1477

1478
  </script>
1479
</body>
1480
</html>`;
1481
}

视频教程：#

操作步骤：#

相关资源：#

优选订阅地址：#

PROXYIP 订阅:#

Worker 代码：代码链接#

Worker 代码：代码链接 #