/g;
const 值正则422 = /| (.+?)<\/td>[\s\S]*? | ([\d.:a-fA-F]+)<\/td>[\s\S]*? | (.+?)<\/td>/;
let 本地值421;
while ((本地值421 = 值正则423.exec(页面)) !== null) {
const 值页面420 = 本地值421[0];
const 值值419 = 值页面420.match(值正则422);
if (值值419 && 值值419[1] && 值值419[2]) {
const 机房 = 值值419[3] ? 值值419[3].trim().replace(/<.*?>/g, '') : '';
结果列表424.push({
isp: 值值419[1].trim().replace(/<.*?>/g, ''),
ip: 值值419[2].trim(),
colo: 机房
});
}
}
if (结果列表424.length === 0) {}
return 结果列表424;
} catch (错误418) {
return [];
}
}
async function 处理网页套接字请求(请求417) {
// 从请求URL的path query中读取客户端自定义参数
// 从 path query 读取覆盖参数
const 请求网址 = new URL(请求417.url);
const 请求回退416 = 请求网址.searchParams.get('p') || '';
const 请求地区415 = (请求网址.searchParams.get('wk') || '').toUpperCase();
const 请求值字符串 = 请求网址.searchParams.get('rm') || '';
const 请求值414 = 请求值字符串 ? 请求值字符串.toLowerCase() !== 'no' : null;
const 请求代理字符串 = 请求网址.searchParams.get('s') || '';
let 请求代理配置413 = null;
if (请求代理字符串) {
try {
请求代理配置413 = 解析代理配置(请求代理字符串);
} catch (忽略值412) {}
}
// 检测并设置当前Worker地区，确保WebSocket请求能正确进行就近匹配
// 优先级：客户端path参数wk > 全局manualWorkerRegion > 自动检测
let 实际地区411 = 当前工作器地区;
if (!实际地区411 || 实际地区411 === '') {
if (请求地区415) {
实际地区411 = 请求地区415;
} else if (手动工作器地区 && 手动工作器地区.trim()) {
实际地区411 = 手动工作器地区.trim().toUpperCase();
} else {
实际地区411 = await 检测工作器地区(请求417);
}
} else if (请求地区415) {
实际地区411 = 请求地区415;
}
const 网页套接字值 = new WebSocketPair();
const [客户端值, 值值410] = Object.values(网页套接字值);
值值410.accept();
值值410.binaryType = 'arraybuffer';
let 远程连接值409 = {
socket: null,
writer: null,
drainUpload: null
};
let 是否域名系统值 = false;
let 协议类型 = null;
let 值值408 = false;
let 传输值 = false;
const 值队列 = 创建块队列(传输上传包大小, 传输上传队列上限, 传输上传队列上限 >> 8);
const 请求值407 = 请求417.fetcher;
function 处理值远程写入器() {
try {
远程连接值409.writer?.releaseLock();
} catch (忽略值406) {}
远程连接值409.writer = null;
}
function 关闭传输() {
if (传输值) return;
传输值 = true;
值队列.clear();
处理值远程写入器();
try {
远程连接值409.socket?.close();
} catch (忽略值405) {}
关闭套接字值(值值410);
}
function 处理队列值(块404) {
const 数据403 = 处理值值8数组(块404);
if (!数据403.byteLength) return true;
if (!值队列.sow(数据403)) {
关闭传输();
return false;
}
远程连接值409.drainUpload();
return true;
}
async function 处理值值402() {
if (值值408 || 传输值 || !远程连接值409.writer) return;
值值408 = true;
try {
for (;;) {
if (传输值 || !远程连接值409.writer) break;
const [数据401] = 值队列.bundle();
if (!数据401) break;
await 远程连接值409.writer.write(数据401);
}
} catch (忽略值400) {
关闭传输();
} finally {
值值408 = false;
if (!值队列.empty && !传输值 && 远程连接值409.writer) queueMicrotask(处理值值402);
}
}
远程连接值409.drainUpload = () => {
if (!值值408 && !值队列.empty && 远程连接值409.writer) queueMicrotask(处理值值402);
};
const 值数据399 = 请求417.headers.get(atob('c2VjLXdlYnNvY2tldC1wcm90b2NvbA==')) || '';
const 本地值398 = 制作值流(值值410, 值数据399);
本地值398.pipeTo(new WritableStream({
async write(块397) {
if (传输值) return;
const 数据396 = 处理值值8数组(块397);
if (是否域名系统值) return await 处理值用户数据报(数据396, 值值410, null, 请求值407);
if (远程连接值409.socket && 远程连接值409.writer) {
if (!处理队列值(数据396)) throw new Error('upload queue overflow');
return;
}
if (协议类型) {
if (!处理队列值(数据396)) throw new Error('upload queue overflow');
return;
}
if (!协议类型) {
if (启用明文 && 数据396.byteLength >= 24) {
const 轻量协议结果 = 解析网页套接字值头部(数据396, 认证令牌);
if (!轻量协议结果.hasError) {
协议类型 = 解码64('dmxlc3M=');
const {
addressType: 地址类型395,
port: 端口394,
hostname: 主机名393,
rawIndex: 原始索引,
version: 本地值392,
isUDP: 是否用户数据报391
} = 轻量协议结果;
if (是否用户数据报391) {
if (端口394 === 53) 是否域名系统值 = true;else throw new Error(错误_仅支持域名系统用户数据报);
}
const 值头部390 = new Uint8Array([本地值392[0], 0]);
const 原始数据389 = 数据396.subarray(原始索引);
if (是否域名系统值) return 处理值用户数据报(原始数据389, 值值410, 值头部390, 请求值407);
await 处理值值384(地址类型395, 主机名393, 端口394, 原始数据389, 值值410, 值头部390, 远程连接值409, 请求回退416, 实际地区411, 请求值414, 请求代理配置413, 请求值407);
return;
}
}
if (启用木马 && 数据396.byteLength >= 56) {
const 值结果 = await 解析木马头部(数据396, 认证令牌);
if (!值结果.hasError) {
协议类型 = atob('dHJvamFu');
const {
addressType: 地址类型388,
port: 端口387,
hostname: 主机名386,
rawClientData: 原始客户端数据
} = 值结果;
await 处理值值384(地址类型388, 主机名386, 端口387, 原始客户端数据, 值值410, null, 远程连接值409, 请求回退416, 实际地区411, 请求值414, 请求代理配置413, 请求值407);
return;
}
}
throw new Error('Invalid protocol or authentication failed');
}
}
})).catch(错误385 => {
关闭传输();
});
return new Response(null, {
status: 101,
webSocket: 客户端值
});
}
async function 处理值值384(地址类型383, 主机, 端口数字, 原始数据, 网页套接字382, 值头部381, 远程连接值, 请求回退 = '', 请求地区 = '', 请求值380 = null, 请求代理配置 = null, 请求值379 = null) {
// 优先使用客户端path参数，其次回退到全局配置
const 实际回退 = 请求回退 || 回退地址;
const 实际地区 = 请求地区 || 当前工作器地区;
const 实际地区匹配 = 请求值380 !== null ? 请求值380 : 启用地区匹配;
const 实际代理配置 = 请求代理配置 || 已解析代理5配置;
const 实际代理已启用 = 请求代理配置 ? true : 是否代理已启用;
const 值数据378 = 处理值值8数组(原始数据);
async function 连接值发送(地址377, 端口376, 值代理 = false) {
const 远程值375 = 值代理 ? await 处理值代理连接(地址类型383, 地址377, 端口376, 实际代理配置) : await 连接值套接字(地址377, 端口376, 请求值379, 传输连接竞速数);
const 写入器374 = 远程值375.writable.getWriter();
if (值数据378.byteLength) await 写入器374.write(值数据378);
return {
remoteSock: 远程值375,
writer: 写入器374
};
}
function 处理值值当前(远程值373, 写入器372) {
if (远程连接值.socket !== 远程值373) return;
try {
写入器372?.releaseLock();
} catch (忽略值371) {}
远程连接值.socket = null;
远程连接值.writer = null;
}
function 处理值远程(远程值370, 写入器369, 重试值368) {
try {
if (远程连接值.writer && 远程连接值.writer !== 写入器369) {
远程连接值.writer.releaseLock();
}
} catch (忽略值367) {}
远程连接值.socket = 远程值370;
远程连接值.writer = 写入器369;
远程连接值.drainUpload?.();
远程值370.closed.catch(() => {}).finally(() => {
if (远程连接值.socket === 远程值370) 关闭套接字值(网页套接字382);
});
连接值279(远程值370, 网页套接字382, 值头部381, 重试值368).finally(() => {
if (远程连接值.socket === 远程值370) {
try {
写入器369.releaseLock();
} catch (忽略值366) {}
远程连接值.writer = null;
}
});
}
async function 处理重试连接() {
if (启用代理降级 && 实际代理已启用) {
try {
const {
remoteSock: 代理套接字,
writer: 代理写入器
} = await 连接值发送(主机, 端口数字, true);
处理值远程(代理套接字, 代理写入器, null);
return;
} catch (代理错误) {
let 备用主机365, 备用端口364;
if (实际回退 && 实际回退.trim()) {
const 已解析363 = 解析地址值端口(实际回退);
备用主机365 = 已解析363.address;
备用端口364 = 已解析363.port || 端口数字;
} else {
const 值备用地址362 = await 获取值备用地址(实际地区, 实际地区匹配);
备用主机365 = 值备用地址362 ? 值备用地址362.domain : 主机;
备用端口364 = 值备用地址362 ? 值备用地址362.port : 端口数字;
}
try {
const {
remoteSock: 回退套接字361,
writer: 回退写入器360
} = await 连接值发送(备用主机365, 备用端口364, false);
处理值远程(回退套接字361, 回退写入器360, null);
} catch (回退错误359) {
关闭套接字值(网页套接字382);
}
}
} else {
let 备用主机, 备用端口;
if (实际回退 && 实际回退.trim()) {
const 已解析 = 解析地址值端口(实际回退);
备用主机 = 已解析.address;
备用端口 = 已解析.port || 端口数字;
} else {
const 值备用地址 = await 获取值备用地址(实际地区, 实际地区匹配);
备用主机 = 值备用地址 ? 值备用地址.domain : 主机;
备用端口 = 值备用地址 ? 值备用地址.port : 端口数字;
}
try {
const {
remoteSock: 回退套接字,
writer: 回退写入器
} = await 连接值发送(备用主机, 备用端口, 实际代理已启用);
处理值远程(回退套接字, 回退写入器, null);
} catch (回退错误) {
关闭套接字值(网页套接字382);
}
}
}
try {
const {
remoteSock: 值套接字358,
writer: 值写入器
} = await 连接值发送(主机, 端口数字, 启用代理降级 ? false : 实际代理已启用);
处理值远程(值套接字358, 值写入器, () => {
处理值值当前(值套接字358, 值写入器);
处理重试连接();
});
} catch (错误357) {
await 处理重试连接();
}
}
function 处理值值8数组(块356) {
if (块356 instanceof Uint8Array) return 块356;
if (块356 instanceof ArrayBuffer) return new Uint8Array(块356);
if (ArrayBuffer.isView(块356)) return new Uint8Array(块356.buffer, 块356.byteOffset, 块356.byteLength);
return new Uint8Array(块356);
}
function 拼接值8数组(头部355, 主体354) {
const 头值353 = 处理值值8数组(头部355);
const 乙值352 = 处理值值8数组(主体354);
const 输出351 = new Uint8Array(头值353.byteLength + 乙值352.byteLength);
输出351.set(头值353);
输出351.set(乙值352, 头值353.byteLength);
return 输出351;
}
function 创建块队列(本地值350, 值值349 = 本地值350, 项目列表上限 = Math.max(1, 值值349 >> 8)) {
let 队列 = [];
let 头部348 = 0;
let 值字节347 = 0;
let 值缓冲346 = null;
function 处理本地值345() {
if (头部348 > 32 && 头部348 * 2 >= 队列.length) {
队列 = 队列.slice(头部348);
头部348 = 0;
}
}
function 处理本地值344() {
if (头部348 >= 队列.length) return null;
const 数据343 = 队列[头部348];
队列[头部348++] = undefined;
值字节347 -= 数据343.byteLength;
处理本地值345();
return 数据343;
}
return {
get empty() {
return 头部348 >= 队列.length;
},
clear() {
队列 = [];
头部348 = 0;
值字节347 = 0;
},
sow(数据342) {
const 数量值 = 数据342?.byteLength || 0;
if (!数量值) return true;
if (值字节347 + 数量值 > 值值349 || 队列.length - 头部348 >= 项目列表上限) return false;
队列.push(数据342);
值字节347 += 数量值;
return true;
},
bundle(数据341 = null) {
数据341 ||= 处理本地值344();
if (!数据341 || 头部348 >= 队列.length || 数据341.byteLength >= 本地值350) return [数据341, false];
let 本地值340 = 数据341.byteLength;
let 结束 = 头部348;
while (结束 < 队列.length) {
const 本地值339 = 队列[结束];
const 值值338 = 本地值340 + 本地值339.byteLength;
if (值值338 > 本地值350) break;
本地值340 = 值值338;
结束++;
}
if (结束 === 头部348) return [数据341, false];
const 输出 = 值缓冲346 ||= new Uint8Array(本地值350);
输出.set(数据341);
let 偏移337 = 数据341.byteLength;
while (头部348 < 结束) {
const 本地值336 = 队列[头部348];
队列[头部348++] = undefined;
值字节347 -= 本地值336.byteLength;
输出.set(本地值336, 偏移337);
偏移337 += 本地值336.byteLength;
}
处理本地值345();
return [输出.subarray(0, 本地值340), true];
}
};
}
function 创建值值(网页套接字335) {
const 本地值334 = 传输下载包大小;
const 尾部 = 传输下载尾部;
const 值值333 = Math.max(4096, 尾部 << 3);
let 本地值332 = new Uint8Array(本地值334);
let 值字节 = 0;
let 计时器 = 0;
let 值值331 = false;
let 本地值330 = 0;
let 值键 = 0;
let 值值329 = 0;
function 刷新() {
if (计时器) clearTimeout(计时器);
计时器 = 0;
值值331 = false;
if (!值字节) return;
if (网页套接字335.readyState === 1) 网页套接字335.send(本地值332.subarray(0, 值字节).slice());
本地值332 = new Uint8Array(本地值334);
值字节 = 0;
值值329 = 0;
}
function 处理本地值() {
if (计时器 || 值值331) return;
值值331 = true;
值键 = 本地值330;
queueMicrotask(() => {
值值331 = false;
if (!值字节 || 计时器) return;
if (本地值334 - 值字节 < 尾部) return 刷新();
计时器 = setTimeout(() => {
计时器 = 0;
if (!值字节) return;
if (本地值334 - 值字节 < 尾部) return 刷新();
if (值值329 < 2 && (本地值330 !== 值键 || 值字节 < 值值333)) {
值值329++;
值键 = 本地值330;
return 处理本地值();
}
刷新();
}, Math.max(传输下载延迟, 1));
});
}
return {
send(块328) {
const 数据327 = 处理值值8数组(块328);
let 偏移326 = 0;
const 本地值325 = 数据327.byteLength;
if (!本地值325) return;
while (偏移326 < 本地值325) {
if (!值字节 && 本地值325 - 偏移326 >= 本地值334) {
const 大小324 = Math.min(本地值334, 本地值325 - 偏移326);
if (网页套接字335.readyState === 1) 网页套接字335.send(偏移326 || 大小324 !== 本地值325 ? 数据327.subarray(偏移326, 偏移326 + 大小324) : 数据327);
偏移326 += 大小324;
continue;
}
const 大小323 = Math.min(本地值334 - 值字节, 本地值325 - 偏移326);
本地值332.set(数据327.subarray(偏移326, 偏移326 + 大小323), 值字节);
值字节 += 大小323;
偏移326 += 大小323;
本地值330++;
if (值字节 === 本地值334 || 本地值334 - 值字节 < 尾部) 刷新();else 处理本地值();
}
},
flush: 刷新
};
}
function 处理打开值套接字(地址322, 端口321, 请求值320 = null) {
const 目标 = {
hostname: 地址322,
port: 端口321
};
if (请求值320 && typeof 请求值320.connect === 'function') return 请求值320.connect(目标);
return 连接(目标);
}
async function 处理打开值套接字值(地址319, 端口318, 请求值317 = null) {
try {
const 套接字316 = 处理打开值套接字(地址319, 端口318, 请求值317);
if (套接字316?.opened) await 套接字316.opened;
return 套接字316;
} catch (错误315) {
if (!请求值317) throw 错误315;
const 套接字314 = 连接({
hostname: 地址319,
port: 端口318
});
if (套接字314?.opened) await 套接字314.opened;
return 套接字314;
}
}
async function 连接值套接字(地址313, 端口312, 请求值311 = null, 竞速数量 = 1) {
const 数量 = Math.max(1, 竞速数量 | 0);
if (数量 <= 1) return 处理打开值套接字值(地址313, 端口312, 请求值311);
const 本地值310 = Array.from({
length: 数量
}, () => 处理打开值套接字值(地址313, 端口312, 请求值311));
const 本地值309 = await Promise.any(本地值310);
本地值310.forEach(本地值308 => {
本地值308.then(套接字307 => {
if (套接字307 !== 本地值309) {
try {
套接字307.close();
} catch (忽略值306) {}
}
}, () => {});
});
return 本地值309;
}
function 获取唯一标识字节(令牌305) {
if (唯一标识字节缓存.has(令牌305)) return 唯一标识字节缓存.get(令牌305);
const 十六进制 = String(令牌305 || '').replace(/-/g, '');
if (十六进制.length !== 32) return null;
const 字节304 = new Uint8Array(16);
for (let 索引值303 = 0; 索引值303 < 16; 索引值303++) {
const 值302 = Number.parseInt(十六进制.slice(索引值303 * 2, 索引值303 * 2 + 2), 16);
if (Number.isNaN(值302)) return null;
字节304[索引值303] = 值302;
}
if (唯一标识字节缓存.size > 16) 唯一标识字节缓存.clear();
唯一标识字节缓存.set(令牌305, 字节304);
return 字节304;
}
function 处理值唯一标识(字节301, 偏移300, 令牌299) {
const 标识298 = 获取唯一标识字节(令牌299);
return !!标识298 && 字节301[偏移300] === 标识298[0] && 字节301[偏移300 + 1] === 标识298[1] && 字节301[偏移300 + 2] === 标识298[2] && 字节301[偏移300 + 3] === 标识298[3] && 字节301[偏移300 + 4] === 标识298[4] && 字节301[偏移300 + 5] === 标识298[5] && 字节301[偏移300 + 6] === 标识298[6] && 字节301[偏移300 + 7] === 标识298[7] && 字节301[偏移300 + 8] === 标识298[8] && 字节301[偏移300 + 9] === 标识298[9] && 字节301[偏移300 + 10] === 标识298[10] && 字节301[偏移300 + 11] === 标识298[11] && 字节301[偏移300 + 12] === 标识298[12] && 字节301[偏移300 + 13] === 标识298[13] && 字节301[偏移300 + 14] === 标识298[14] && 字节301[偏移300 + 15] === 标识298[15];
}
function 解析网页套接字值头部(块297, 令牌) {
const 字节296 = 处理值值8数组(块297);
if (字节296.byteLength < 24) return {
hasError: true,
message: 错误_无效数据
};
const 本地值295 = 字节296.subarray(0, 1);
if (!处理值唯一标识(字节296, 1, 令牌)) return {
hasError: true,
message: 错误_无效用户
};
const 值长度294 = 字节296[17];
const 命令索引 = 18 + 值长度294;
if (字节296.byteLength < 命令索引 + 5) return {
hasError: true,
message: 错误_无效数据
};
const 命令293 = 字节296[命令索引];
let 是否用户数据报 = false;
if (命令293 === 1) {} else if (命令293 === 2) {
是否用户数据报 = true;
} else {
return {
hasError: true,
message: 错误_不支持命令
};
}
const 端口索引292 = 19 + 值长度294;
const 端口291 = 字节296[端口索引292] << 8 | 字节296[端口索引292 + 1];
let 地址索引290 = 端口索引292 + 2,
地址长度289 = 0,
地址值索引 = 地址索引290 + 1,
主机名288 = '';
const 地址类型287 = 字节296[地址索引290];
switch (地址类型287) {
case 地址类型_四版:
地址长度289 = 4;
if (字节296.byteLength < 地址值索引 + 地址长度289) return {
hasError: true,
message: 错误_无效数据
};
主机名288 = `${字节296[地址值索引]}.${字节296[地址值索引 + 1]}.${字节296[地址值索引 + 2]}.${字节296[地址值索引 + 3]}`;
break;
case 地址类型_网址:
if (字节296.byteLength < 地址值索引 + 1) return {
hasError: true,
message: 错误_无效数据
};
地址长度289 = 字节296[地址值索引++];
if (字节296.byteLength < 地址值索引 + 地址长度289) return {
hasError: true,
message: 错误_无效数据
};
主机名288 = 共享解码器.decode(字节296.subarray(地址值索引, 地址值索引 + 地址长度289));
break;
case 地址类型_六版:
地址长度289 = 16;
if (字节296.byteLength < 地址值索引 + 地址长度289) return {
hasError: true,
message: 错误_无效数据
};
const 值6286 = [];
const 值6视图 = new DataView(字节296.buffer, 字节296.byteOffset + 地址值索引, 地址长度289);
for (let 索引值285 = 0; 索引值285 < 8; 索引值285++) 值6286.push(值6视图.getUint16(索引值285 * 2).toString(16));
主机名288 = 值6286.join(':');
break;
default:
return {
hasError: true,
message: `${错误_无效地址类型}: ${地址类型287}`
};
}
if (!主机名288) return {
hasError: true,
message: `${错误_空地址}: ${地址类型287}`
};
return {
hasError: false,
addressType: 地址类型287,
port: 端口291,
hostname: 主机名288,
isUDP: 是否用户数据报,
rawIndex: 地址值索引 + 地址长度289,
version: 本地值295
};
}
function 制作值流(套接字284, 值数据头部) {
let 本地值283 = false;
return new ReadableStream({
start(控制器282) {
套接字284.addEventListener('message', 事件 => {
if (!本地值283) 控制器282.enqueue(处理值值8数组(事件.data));
});
套接字284.addEventListener('close', () => {
if (!本地值283) {
关闭套接字值(套接字284);
控制器282.close();
}
});
套接字284.addEventListener('error', 错误281 => 控制器282.error(错误281));
const {
earlyData: 值数据,
error: 错误280
} = 处理基础64值数组(值数据头部);
if (错误280) 控制器282.error(错误280);else if (值数据) 控制器282.enqueue(处理值值8数组(值数据));
},
cancel() {
本地值283 = true;
关闭套接字值(套接字284);
}
});
}
async function 连接值279(远程套接字, 网页套接字278, 头部数据, 重试值) {
let 头部277 = 头部数据,
是否有数据 = false,
本地值276 = false;
// 关键：直连有时握手成功但远端长时间无数据，需要超时触发降级
let 首次字节计时器 = null;
if (重试值) {
首次字节计时器 = setTimeout(() => {
if (!是否有数据 && !本地值276) {
本地值276 = true;
try {
远程套接字.close && 远程套接字.close();
} catch (忽略值275) {}
重试值();
}
}, 首字节超时);
}
const 本地值274 = 创建值值(网页套接字278);
let 读取器273 = null;
let 本地值272 = true;
let 缓冲271 = new ArrayBuffer(传输块大小);
try {
try {
读取器273 = 远程套接字.readable.getReader({
mode: 'byob'
});
} catch (忽略值270) {
本地值272 = false;
读取器273 = 远程套接字.readable.getReader();
}
for (;;) {
const 结果269 = 本地值272 ? await 读取器273.read(new Uint8Array(缓冲271, 0, 传输块大小)) : await 读取器273.read();
if (结果269.done) break;
const 读取值 = 结果269.value;
let 块268 = 处理值值8数组(读取值);
const 值缓冲 = 本地值272 && 读取值?.buffer instanceof ArrayBuffer && 读取值.buffer.byteLength >= 传输块大小 ? 读取值.buffer : new ArrayBuffer(传输块大小);
if (!块268.byteLength) continue;
if (!是否有数据) {
是否有数据 = true;
if (首次字节计时器) {
clearTimeout(首次字节计时器);
首次字节计时器 = null;
}
}
if (网页套接字278.readyState !== 1) throw new Error(错误_网页套接字未打开);
if (头部277) {
块268 = 拼接值8数组(头部277, 块268);
头部277 = null;
}
if (块268.byteLength >= 传输块大小 >> 1) {
本地值274.flush();
网页套接字278.send(块268);
if (本地值272) 缓冲271 = new ArrayBuffer(传输块大小);
} else {
本地值274.send(块268.slice());
if (本地值272) 缓冲271 = 值缓冲;
}
}
本地值274.flush();
} catch (错误267) {
// 已经触发 retry 时不要关闭 WS（retry 会重新挂载新 socket）
if (!本地值276) 关闭套接字值(网页套接字278);
} finally {
try {
本地值274.flush();
} catch (忽略值266) {}
try {
读取器273?.releaseLock();
} catch (忽略值265) {}
}
if (首次字节计时器) {
clearTimeout(首次字节计时器);
首次字节计时器 = null;
}
if (!是否有数据 && !本地值276 && 重试值) 重试值();
}
async function 处理值用户数据报(用户数据报块, 网页套接字, 值头部, 请求值 = null) {
try {
const 值套接字 = await 连接值套接字('8.8.4.4', 53, 请求值, 1);
let 头部 = 值头部;
const 写入器264 = 值套接字.writable.getWriter();
await 写入器264.write(用户数据报块);
写入器264.releaseLock();
await 连接值279(值套接字, 网页套接字, 头部, null);
} catch (错误263) {}
}
async function 处理值代理连接(地址类型, 地址262, 端口261, 代理配置 = 已解析代理5配置) {
const {
username: 本地值260,
password: 密码259,
hostname: 主机名258,
socksPort: 代理端口257
} = 代理配置;
const 套接字256 = 连接({
hostname: 主机名258,
port: 代理端口257
});
const 写入器255 = 套接字256.writable.getWriter();
await 写入器255.write(new Uint8Array(本地值260 ? [5, 2, 0, 2] : [5, 1, 0]));
const 读取器254 = 套接字256.readable.getReader();
let 本地值253 = (await 读取器254.read()).value;
if (本地值253[0] !== 5 || 本地值253[1] === 255) throw new Error(错误_代理无可用方法);
if (本地值253[1] === 2) {
if (!本地值260 || !密码259) throw new Error(错误_代理需要认证);
const 编码器252 = new TextEncoder();
const 认证请求 = new Uint8Array([1, 本地值260.length, ...编码器252.encode(本地值260), 密码259.length, ...编码器252.encode(密码259)]);
await 写入器255.write(认证请求);
本地值253 = (await 读取器254.read()).value;
if (本地值253[0] !== 1 || 本地值253[1] !== 0) throw new Error(错误_代理认证失败);
}
const 编码器251 = new TextEncoder();
let 本地值250;
switch (地址类型) {
case 地址类型_四版:
本地值250 = new Uint8Array([1, ...地址262.split('.').map(Number)]);
break;
case 地址类型_网址:
本地值250 = new Uint8Array([3, 地址262.length, ...编码器251.encode(地址262)]);
break;
case 地址类型_六版:
本地值250 = new Uint8Array([4, ...地址262.split(':').flatMap(横值 => [parseInt(横值.slice(0, 2), 16), parseInt(横值.slice(2), 16)])]);
break;
default:
throw new Error(错误_无效地址类型);
}
await 写入器255.write(new Uint8Array([5, 1, 0, ...本地值250, 端口261 >> 8, 端口261 & 255]));
本地值253 = (await 读取器254.read()).value;
if (本地值253[1] !== 0) throw new Error(错误_代理连接失败);
写入器255.releaseLock();
读取器254.releaseLock();
return 套接字256;
}
function 解析代理配置(地址249) {
let [本地值248, 本地值247] = 地址249.split("@").reverse();
let 本地值246, 密码245, 主机名244, 代理端口;
if (本地值247) {
const 本地值243 = 本地值247.split(":");
if (本地值243.length !== 2) throw new Error(错误_无效代理地址);
[本地值246, 密码245] = 本地值243;
}
const 本地值242 = 本地值248.split(":");
代理端口 = Number(本地值242.pop());
if (isNaN(代理端口)) throw new Error(错误_无效代理地址);
主机名244 = 本地值242.join(":");
if (主机名244.includes(":") && !/^\[.*\]$/.test(主机名244)) throw new Error(错误_无效代理地址);
return {
username: 本地值246,
password: 密码245,
hostname: 主机名244,
socksPort: 代理端口
};
}
async function 处理订阅值(请求241, 用户240 = null) {
if (!用户240) 用户240 = 认证令牌;
const 网址239 = new URL(请求241.url);
// 优先检查Cookie中的语言设置
const 凭据头部 = 请求241.headers.get('Cookie') || '';
let 语言来源凭据 = null;
if (凭据头部) {
const 本地值238 = 凭据头部.split(';').map(丙值237 => 丙值237.trim());
for (const 凭据 of 本地值238) {
if (凭据.startsWith('preferredLanguage=')) {
语言来源凭据 = 凭据.split('=')[1];
break;
}
}
}
let 是否值236 = false;
if (语言来源凭据 === 'fa' || 语言来源凭据 === 'fa-IR') {
是否值236 = true;
} else if (语言来源凭据 === 'zh' || 语言来源凭据 === 'zh-CN') {
是否值236 = false;
} else {
// 如果没有Cookie，使用浏览器语言检测
const 接受语言 = 请求241.headers.get('Accept-Language') || '';
const 浏览器语言 = 接受语言.split(',')[0].split('-')[0].toLowerCase();
是否值236 = 浏览器语言 === 'fa' || 接受语言.includes('fa-IR') || 接受语言.includes('fa');
}
const 语言值 = 是否值236 ? 'fa-IR' : 'zh-CN';
const 本地值235 = {
zh: {
title: 解码64('6K6i6ZiF5Lit5b+D'),
subtitle: '多客户端支持 • 智能优选 • 一键生成',
selectClient: '[ 选择客户端 ]',
systemStatus: '[ 系统状态 ]',
configManagement: '[ 配置管理 ]',
relatedLinks: '[ 相关链接 ]',
checking: '检测中...',
workerRegion: 'Worker地区: ',
detectionMethod: '检测方式: ',
proxyIPStatus: 解码64('UHJveHlJUOeKtuaAgTog'),
currentIP: '当前使用IP: ',
regionMatch: '地区匹配: ',
selectionLogic: '选择逻辑: ',
kvStatusChecking: '检测KV状态中...',
kvEnabled: '✅ KV存储已启用，可以使用配置管理功能',
kvDisabled: '⚠️ KV存储未启用或未配置',
specifyRegion: '指定地区 (wk):',
autoDetect: '自动检测',
saveRegion: '保存地区配置',
protocolSelection: 解码64('5Y2P6K6u6YCJ5oupOg=='),
enableVLESS: 解码64('5ZCv55SoIFZMRVNTIOWNj+iurg=='),
enableTrojan: 解码64('5ZCv55SoIFRyb2phbiDljY/orq4='),
enableXhttp: 解码64('5ZCv55SoIHhodHRwIOWNj+iurg=='),
trojanPassword: 解码64('VHJvamFuIOWvhueggSAo5Y+v6YCJKTo='),
customPath: '自定义路径 (d):',
customIP: 解码64('6Ieq5a6a5LmJUHJveHlJUCAocCk6'),
preferredIPs: '优选IP列表 (yx):',
preferredIPsURL: '优选IP来源URL (yxURL):',
latencyTest: '延迟测试',
latencyTestIP: '测试IP/域名:',
latencyTestIPPlaceholder: '输入IP或域名，多个用逗号分隔',
latencyTestPort: '端口:',
startTest: '开始测试',
stopTest: '停止测试',
testResult: '测试结果:',
addToYx: '添加到优选列表',
addSelectedToYx: '添加选中项到优选列表',
selectAll: '全选',
deselectAll: '取消全选',
testingInProgress: '测试中...',
testComplete: '测试完成',
latencyMs: '延迟',
timeout: '超时',
ipSource: 'IP来源:',
manualInput: '手动输入',
cfRandomIP: 'CF随机IP',
urlFetch: 'URL获取',
randomCount: '生成数量:',
fetchURL: '获取URL:',
fetchURLPlaceholder: '输入优选IP的URL地址',
generateIP: '生成IP',
fetchIP: '获取IP',
socks5Config: 解码64('U09DS1M16YWN572uIChzKTo='),
customHomepage: '自定义首页URL (homepage):',
customHomepagePlaceholder: '例如: https://example.com',
customHomepageHint: '设置自定义URL作为首页伪装。访问根路径 / 时将显示该URL的内容。留空则显示默认终端页面。',
saveConfig: '保存配置',
advancedControl: '高级控制',
subscriptionConverter: 解码64('6K6i6ZiF6L2s5o2i5Zyw5Z2AOg=='),
builtinPreferred: '内置优选类型:',
enablePreferredDomain: '启用优选域名',
enablePreferredIP: '启用优选 IP',
enableNativeAddress: '启用原生地址',
enableGitHubPreferred: '启用自定义优选',
allowAPIManagement: '允许API管理 (ae):',
regionMatching: '地区匹配 (rm):',
downgradeControl: '降级控制 (qj):',
tlsControl: 'TLS控制 (dkby):',
preferredControl: '优选控制 (yxby):',
saveAdvanced: '保存高级配置',
loading: '加载中...',
currentConfig: '📍 当前路径配置',
refreshConfig: '刷新配置',
resetConfig: '重置配置',
subscriptionCopied: 解码64('6K6i6ZiF6ZO+5o6l5bey5aSN5Yi2'),
autoSubscriptionCopied: 解码64('6Ieq5Yqo6K+G5Yir6K6i6ZiF6ZO+5o6l5bey5aSN5Yi277yM5a6i5oi356uv6K6/6Zeu5pe25Lya5qC55o2uVXNlci1BZ2VudOiHquWKqOivhuWIq+W5tui/lOWbnuWvueW6lOagvOW8jw=='),
trojanPasswordPlaceholder: '留空则自动使用 UUID',
trojanPasswordHint: 解码64('6K6+572u6Ieq5a6a5LmJIFRyb2phbiDlr4bnoIHjgILnlZnnqbrliJnkvb/nlKggVVVJROOAguWuouaIt+err+S8muiHquWKqOWvueWvhueggei/m+ihjCBTSEEyMjQg5ZOI5biM44CC'),
protocolHint: 解码64('5Y+v5Lul5ZCM5pe25ZCv55So5aSa5Liq5Y2P6K6u44CC6K6i6ZiF5bCG55Sf5oiQ6YCJ5Lit5Y2P6K6u55qE6IqC54K544CCPGJyPuKAoiBWTEVTUyBXUzog5Z+65LqOIFdlYlNvY2tldCDnmoTmoIflh4bljY/orq48YnI+4oCiIFRyb2phbjog5L2/55SoIFNIQTIyNCDlr4bnoIHorqTor4E8YnI+4oCiIHhodHRwOiDln7rkuo4gSFRUUCBQT1NUIOeahOS8quijheWNj+iuru+8iOmcgOimgee7keWumuiHquWumuS5ieWfn+WQjeW5tuW8gOWQryBnUlBD77yJ'),
enableECH: '启用 ECH (Encrypted Client Hello)',
enableECHHint: 解码64('5ZCv55So5ZCO77yM5q+P5qyh5Yi35paw6K6i6ZiF5pe25Lya6Ieq5Yqo5LuOIERvSCDojrflj5bmnIDmlrDnmoQgRUNIIOmFjee9ruW5tua3u+WKoOWIsOmTvuaOpeS4rQ=='),
customDNS: '自定义 DNS 服务器',
customDNSPlaceholder: '例如: https://223.5.5.5/dns-query',
customDNSHint: '用于ECH配置查询的DNS服务器地址（DoH格式）',
customECHDomain: '自定义 ECH 域名',
customECHDomainPlaceholder: '例如: cloudflare-ech.com',
customECHDomainHint: 'ECH配置中使用的域名，留空则使用默认值',
alpn: 'TLS ALPN',
alpnDefault: '默认（留空，由客户端协商）',
alpnHint: '仅添加到 TLS 节点链接参数；留空则不写 alpn。',
saveProtocol: 解码64('5L+d5a2Y5Y2P6K6u6YWN572u'),
subscriptionConverterPlaceholder: '默认: https://url.v1.mk/sub',
subscriptionConverterHint: 解码64('6K6i6ZiF6L2s5o2i5bey5YaF6YOo5a6e546w77yM5peg6ZyA5aSW6YOoIEFQSeOAguatpOmhueS7heS9nOWFvOWuueS/neeVme+8jOWPr+eVmeepuuOAgg=='),
builtinPreferredHint: 解码64('5o6n5Yi26K6i6ZiF5Lit5YyF5ZCr5ZOq5Lqb5YaF572u5LyY6YCJ6IqC54K544CC6buY6K6k5YWo6YOo5ZCv55So44CC'),
apiEnabledDefault: '默认（关闭API）',
apiEnabledYes: '开启API管理',
apiEnabledHint: '⚠️ 安全提醒：开启后允许通过API动态添加优选IP。建议仅在需要时开启。',
regionMatchingDefault: '默认（启用地区匹配）',
regionMatchingNo: '关闭地区匹配',
regionMatchingHint: '设置为"关闭"时不进行地区智能匹配',
downgradeControlDefault: '默认（不启用降级）',
downgradeControlNo: '启用降级模式',
downgradeControlHint: 解码64('6K6+572u5Li6IuWQr+eUqCLml7bvvJpDRuebtOi/nuWksei0peKGklNPQ0tTNei/nuaOpeKGkmZhbGxiYWNr5Zyw5Z2A'),
tlsControlDefault: '默认（保留所有节点）',
tlsControlYes: '仅TLS节点',
tlsControlHint: '设置为"仅TLS节点"时只生成带TLS的节点，不生成非TLS节点（如80端口）',
preferredControlDefault: '默认（启用优选）',
preferredControlYes: '关闭优选',
preferredControlHint: '设置为"关闭优选"时只使用原生地址，不生成优选IP和域名节点',
regionNames: {
HK: '🇭🇰 香港',
US: '🇺🇸 美国',
SG: '🇸🇬 新加坡',
JP: '🇯🇵 日本',
KR: '🇰🇷 韩国',
DE: '🇩🇪 德国',
SE: '🇸🇪 瑞典',
NL: '🇳🇱 荷兰',
FI: '🇫🇮 芬兰',
GB: '🇬🇧 英国'
},
terminal: '终端 v2.9.8c',
githubProject: 'GitHub 项目',
优选工具: '优选工具',
autoDetectClient: '自动识别',
selectionLogicText: '同地区 → 邻近地区 → 其他地区',
customIPDisabledHint: 解码64('5L2/55So6Ieq5a6a5LmJUHJveHlJUOaXtu+8jOWcsOWMuumAieaLqeW3suemgeeUqA=='),
customIPMode: 解码64('6Ieq5a6a5LmJUHJveHlJUOaooeW8jyAocOWPmOmHj+WQr+eUqCk='),
customIPModeDesc: '自定义IP模式 (已禁用地区匹配)',
usingCustomProxyIP: 解码64('5L2/55So6Ieq5a6a5LmJUHJveHlJUDog'),
customIPConfig: ' (p变量配置)',
customIPModeDisabled: '自定义IP模式，地区选择已禁用',
manualRegion: '手动指定地区',
manualRegionDesc: ' (手动指定)',
proxyIPAvailable: 解码64('MTAvMTAg5Y+v55SoIChQcm94eUlQ5Z+f5ZCN6aKE6K6+5Y+v55SoKQ=='),
smartSelection: '智能就近选择中',
sameRegionIP: '同地区IP可用 (1个)',
cloudflareDetection: 'Cloudflare内置检测',
detectionFailed: '检测失败',
apiTestResult: 'API检测结果: ',
apiTestTime: '检测时间: ',
apiTestFailed: 'API检测失败: ',
unknownError: '未知错误',
apiTestError: 'API测试失败: ',
kvNotConfigured: 'KV存储未配置，无法使用配置管理功能。\\n\\n请在Cloudflare Workers中:\\n1. 创建KV命名空间\\n2. 绑定环境变量 C\\n3. 重新部署代码',
kvNotEnabled: 'KV存储未配置',
kvCheckFailed: 'KV存储检测失败: 响应格式错误',
kvCheckFailedStatus: 'KV存储检测失败 - 状态码: ',
kvCheckFailedError: 'KV存储检测失败 - 错误: '
},
fa: {
title: 'مرکز اشتراک',
subtitle: 'پشتیبانی چند کلاینت • انتخاب هوشمند • تولید یک کلیکی',
selectClient: '[ انتخاب کلاینت ]',
systemStatus: '[ وضعیت سیستم ]',
configManagement: '[ مدیریت تنظیمات ]',
relatedLinks: '[ لینکهای مرتبط ]',
checking: 'در حال بررسی...',
workerRegion: 'منطقه Worker: ',
detectionMethod: 'روش تشخیص: ',
proxyIPStatus: 解码64('2YjYtti524zYqiBQcm94eUlQOiA='),
currentIP: 'IP فعلی: ',
regionMatch: 'تطبیق منطقه: ',
selectionLogic: 'منطق انتخاب: ',
kvStatusChecking: 'در حال بررسی وضعیت KV...',
kvEnabled: '✅ ذخیرهسازی KV فعال است، میتوانید از مدیریت تنظیمات استفاده کنید',
kvDisabled: '⚠️ ذخیرهسازی KV فعال نیست یا پیکربندی نشده است',
specifyRegion: 'تعیین منطقه (wk):',
autoDetect: 'تشخیص خودکار',
saveRegion: 'ذخیره تنظیمات منطقه',
protocolSelection: 'انتخاب پروتکل:',
enableVLESS: 解码64('2YHYudin2YTigIzYs9in2LLbjCDZvtix2YjYqtqp2YQgVkxFU1M='),
enableTrojan: 解码64('2YHYudin2YTigIzYs9in2LLbjCDZvtix2YjYqtqp2YQgVHJvamFu'),
enableXhttp: 'فعالسازی پروتکل xhttp',
enableECH: 'فعالسازی ECH (Encrypted Client Hello)',
enableECHHint: 'پس از فعالسازی، در هر بار تازهسازی اشتراک، پیکربندی ECH بهروز بهطور خودکار از DoH دریافت شده و به لینکها اضافه میشود',
customDNS: 'سرور DNS سفارشی',
customDNSPlaceholder: 'مثال: https://223.5.5.5/dns-query',
customDNSHint: 'آدرس سرور DNS برای جستجوی پیکربندی ECH (فرمت DoH)',
customECHDomain: 'دامنه ECH سفارشی',
customECHDomainPlaceholder: 'مثال: cloudflare-ech.com',
customECHDomainHint: 'دامنه استفاده شده در پیکربندی ECH، خالی بگذارید تا از مقدار پیشفرض استفاده شود',
trojanPassword: 解码64('2LHZhdiyINi52KjZiNixIFRyb2phbiAo2KfYrtiq24zYp9ix24wpOg=='),
customPath: 'مسیر سفارشی (d):',
customIP: 解码64('UHJveHlJUCDYs9mB2KfYsdi024wgKHApOg=='),
preferredIPs: 'لیست IP ترجیحی (yx):',
preferredIPsURL: 'URL منبع IP ترجیحی (yxURL):',
latencyTest: 'تست تاخیر',
latencyTestIP: 'IP/دامنه تست:',
latencyTestIPPlaceholder: 'IP یا دامنه وارد کنید، چند مورد با کاما جدا شوند',
latencyTestPort: 'پورت:',
startTest: 'شروع تست',
stopTest: 'توقف تست',
testResult: 'نتیجه تست:',
addToYx: 'افزودن به لیست ترجیحی',
addSelectedToYx: 'افزودن موارد انتخاب شده',
selectAll: 'انتخاب همه',
deselectAll: 'لغو انتخاب',
testingInProgress: 'در حال تست...',
testComplete: 'تست کامل شد',
latencyMs: 'تاخیر',
timeout: 'زمان تمام شد',
ipSource: 'منبع IP:',
manualInput: 'ورودی دستی',
cfRandomIP: 'IP تصادفی CF',
urlFetch: 'دریافت از URL',
randomCount: 'تعداد تولید:',
fetchURL: 'URL دریافت:',
fetchURLPlaceholder: 'آدرس URL لیست IP را وارد کنید',
generateIP: 'تولید IP',
fetchIP: 'دریافت IP',
socks5Config: 解码64('2KrZhti424zZhdin2KogU09DS1M1IChzKTo='),
customHomepage: 'URL صفحه اصلی سفارشی (homepage):',
customHomepagePlaceholder: 'مثال: https://example.com',
customHomepageHint: 'تنظیم URL سفارشی به عنوان استتار صفحه اصلی. هنگام دسترسی به مسیر اصلی / محتوای این URL نمایش داده میشود. اگر خالی بگذارید صفحه ترمینال پیشفرض نمایش داده میشود.',
saveConfig: 'ذخیره تنظیمات',
advancedControl: 'کنترل پیشرفته',
subscriptionConverter: 'آدرس تبدیل اشتراک:',
builtinPreferred: 'نوع ترجیحی داخلی:',
enablePreferredDomain: 'فعالسازی دامنه ترجیحی',
enablePreferredIP: 'فعالسازی IP ترجیحی',
enableNativeAddress: 'فعالسازی آدرس اصلی',
enableGitHubPreferred: 'فعالسازی ترجیح سفارشی',
allowAPIManagement: 'اجازه مدیریت API (ae):',
regionMatching: 'تطبیق منطقه (rm):',
downgradeControl: 'کنترل کاهش سطح (qj):',
tlsControl: 'کنترل TLS (dkby):',
preferredControl: 'کنترل ترجیحی (yxby):',
saveAdvanced: 'ذخیره تنظیمات پیشرفته',
loading: 'در حال بارگذاری...',
currentConfig: '📍 پیکربندی مسیر فعلی',
refreshConfig: 'تازهسازی تنظیمات',
resetConfig: 'بازنشانی تنظیمات',
subscriptionCopied: 'لینک اشتراک کپی شد',
autoSubscriptionCopied: 'لینک اشتراک تشخیص خودکار کپی شد، کلاینت هنگام دسترسی بر اساس User-Agent به طور خودکار تشخیص داده و قالب مربوطه را برمیگرداند',
trojanPasswordPlaceholder: 'خالی بگذارید تا از UUID استفاده شود',
trojanPasswordHint: 解码64('2LHZhdiyINi52KjZiNixIFRyb2phbiDYs9mB2KfYsdi024wg2LHYpyDYqtmG2LjbjNmFINqp2YbbjNivLiDYp9qv2LEg2K7Yp9mE24wg2Kjar9iw2KfYsduM2K8g2KfYsiBVVUlEINin2LPYqtmB2KfYr9mHINmF24zigIzYtNmI2K8uINqp2YTYp9uM2YbYqiDYqNmHINi32YjYsSDYrtmI2K/aqdin2LEg2LHZhdiyINi52KjZiNixINix2Kcg2KjYpyBTSEEyMjQg2YfYtCDZhduM4oCM2qnZhtivLg=='),
protocolHint: 解码64('2YXbjOKAjNiq2YjYp9mG24zYryDahtmG2K/bjNmGINm+2LHZiNiq2qnZhCDYsdinINmH2YXYstmF2KfZhiDZgdi52KfZhCDaqdmG24zYry4g2KfYtNiq2LHYp9qpINqv2LHZh+KAjNmH2KfbjCDZvtix2YjYqtqp2YTigIzZh9in24wg2KfZhtiq2K7Yp9ioINi02K/ZhyDYsdinINiq2YjZhNuM2K8g2YXbjOKAjNqp2YbYry48YnI+4oCiIFZMRVNTIFdTOiDZvtix2YjYqtqp2YQg2KfYs9iq2KfZhtiv2KfYsdivINmF2KjYqtmG24wg2KjYsSBXZWJTb2NrZXQ8YnI+4oCiIFRyb2phbjog2KfYrdix2KfYsiDZh9mI24zYqiDYqNinINix2YXYsiDYudio2YjYsSBTSEEyMjQ8YnI+4oCiIHhodHRwOiDZvtix2YjYqtqp2YQg2KfYs9iq2KrYp9ixINmF2KjYqtmG24wg2KjYsSBIVFRQIFBPU1QgKNmG24zYp9iyINio2Ycg2KfYqti12KfZhCDYr9in2YXZhtmHINiz2YHYp9ix2LTbjCDZiCDZgdi52KfZhOKAjNiz2KfYstuMIGdSUEMg2K/Yp9ix2K8p'),
alpn: 'TLS ALPN',
alpnDefault: 'پیشفرض (خالی، مذاکره توسط کلاینت)',
alpnHint: 'فقط به لینکهای TLS اضافه میشود؛ اگر خالی باشد alpn نوشته نمیشود.',
saveProtocol: 'ذخیره تنظیمات پروتکل',
subscriptionConverterPlaceholder: 'پیشفرض: https://url.v1.mk/sub',
subscriptionConverterHint: 'تبدیل اشتراک به صورت داخلی پیادهسازی شده است و نیازی به API خارجی ندارد. این فیلد فقط برای سازگاری حفظ شده و میتوان آن را خالی گذاشت.',
builtinPreferredHint: 'کنترل اینکه کدام گرههای ترجیحی داخلی در اشتراک گنجانده شوند. به طور پیشفرض همه فعال هستند.',
apiEnabledDefault: 'پیشفرض (بستن API)',
apiEnabledYes: 'فعالسازی مدیریت API',
apiEnabledHint: '⚠️ هشدار امنیتی: فعالسازی این گزینه اجازه میدهد IP های ترجیحی از طریق API به طور پویا اضافه شوند. توصیه میشود فقط در صورت نیاز فعال کنید.',
regionMatchingDefault: 'پیشفرض (فعالسازی تطبیق منطقه)',
regionMatchingNo: 'بستن تطبیق منطقه',
regionMatchingHint: 'وقتی "بستن" تنظیم شود، تطبیق هوشمند منطقه انجام نمیشود',
downgradeControlDefault: 'پیشفرض (عدم فعالسازی کاهش سطح)',
downgradeControlNo: 'فعالسازی حالت کاهش سطح',
downgradeControlHint: 解码64('2YjZgtiq24wgItmB2LnYp9mEIiDYqtmG2LjbjNmFINi02YjYrzog2KfYqti12KfZhCDZhdiz2KrZgtuM2YUgQ0Yg2YbYp9mF2YjZgdmCIOKGkiDYp9iq2LXYp9mEIFNPQ0tTNSDihpIg2KLYr9ix2LMgZmFsbGJhY2s='),
tlsControlDefault: 'پیشفرض (حفظ همه گرهها)',
tlsControlYes: 'فقط گرههای TLS',
tlsControlHint: 'وقتی "فقط گرههای TLS" تنظیم شود، فقط گرههای با TLS تولید میشوند، گرههای غیر TLS (مانند پورت 80) تولید نمیشوند',
preferredControlDefault: 'پیشفرض (فعالسازی ترجیح)',
preferredControlYes: 'بستن ترجیح',
preferredControlHint: 'وقتی "بستن ترجیح" تنظیم شود، فقط از آدرس اصلی استفاده میشود، گرههای IP و دامنه ترجیحی تولید نمیشوند',
regionNames: {
HK: '🇭🇰 هنگ کنگ',
US: '🇺🇸 آمریکا',
SG: '🇸🇬 سنگاپور',
JP: '🇯🇵 ژاپن',
KR: '🇰🇷 کره جنوبی',
DE: '🇩🇪 آلمان',
SE: '🇸🇪 سوئد',
NL: '🇳🇱 هلند',
FI: '🇫🇮 فنلاند',
GB: '🇬🇧 بریتانیا'
},
terminal: 'ترمینال v2.9.8c',
githubProject: 'پروژه GitHub',
优选工具: 'ابزار ترجیح IP',
autoDetectClient: 'تشخیص خودکار',
selectionLogicText: 'هممنطقه → منطقه مجاور → سایر مناطق',
customIPDisabledHint: 解码64('2YfZhtqv2KfZhSDYp9iz2KrZgdin2K/ZhyDYp9iyIFByb3h5SVAg2LPZgdin2LHYtNuM2Iwg2KfZhtiq2K7Yp9ioINmF2YbYt9mC2Ycg2LrbjNix2YHYudin2YQg2KfYs9iq'),
customIPMode: 解码64('2K3Yp9mE2KogUHJveHlJUCDYs9mB2KfYsdi024wgKNmF2KrYutuM2LEgcCDZgdi52KfZhCDYp9iz2Kop'),
customIPModeDesc: 'حالت IP سفارشی (تطبیق منطقه غیرفعال است)',
usingCustomProxyIP: 解码64('2KfYs9iq2YHYp9iv2Ycg2KfYsiBQcm94eUlQINiz2YHYp9ix2LTbjDog'),
customIPConfig: ' (پیکربندی متغیر p)',
customIPModeDisabled: 'حالت IP سفارشی، انتخاب منطقه غیرفعال است',
manualRegion: 'تعیین منطقه دستی',
manualRegionDesc: ' (تعیین دستی)',
proxyIPAvailable: 解码64('MTAvMTAg2K/YsSDYr9iz2KrYsdizICjYr9in2YXZhtmHINm+24zYtOKAjNmB2LHYtiBQcm94eUlQINiv2LEg2K/Ys9iq2LHYsyDYp9iz2Kop'),
smartSelection: 'انتخاب هوشمند نزدیک در حال انجام است',
sameRegionIP: 'IP هممنطقه در دسترس است (1)',
cloudflareDetection: 'تشخیص داخلی Cloudflare',
detectionFailed: 'تشخیص ناموفق',
apiTestResult: 'نتیجه تشخیص API: ',
apiTestTime: 'زمان تشخیص: ',
apiTestFailed: 'تشخیص API ناموفق: ',
unknownError: 'خطای ناشناخته',
apiTestError: 'تست API ناموفق: ',
kvNotConfigured: 'ذخیرهسازی KV پیکربندی نشده است، نمیتوانید از عملکرد مدیریت تنظیمات استفاده کنید.\\n\\nلطفا در Cloudflare Workers:\\n1. فضای نام KV ایجاد کنید\\n2. متغیر محیطی C را پیوند دهید\\n3. کد را دوباره مستقر کنید',
kvNotEnabled: 'ذخیرهسازی KV پیکربندی نشده است',
kvCheckFailed: 'بررسی ذخیرهسازی KV ناموفق: خطای فرمت پاسخ',
kvCheckFailedStatus: 'بررسی ذخیرهسازی KV ناموفق - کد وضعیت: ',
kvCheckFailedError: 'بررسی ذخیرهسازی KV ناموفق - خطا: '
}
};
const 翻译值 = 本地值235[是否值236 ? 'fa' : 'zh'];
const 值页面 = `
${翻译值.title}
SYS:: ${翻译值.terminal}
NODE:: NIGHT_CITY
LINK:: SECURE / ENC
LANG_
${翻译值.selectClient}
${翻译值.systemStatus}
[ ${翻译值.checking} ]
${翻译值.workerRegion}${翻译值.checking}
${翻译值.detectionMethod}${翻译值.checking}
${翻译值.proxyIPStatus}${翻译值.checking}
${翻译值.currentIP}${翻译值.checking}
ECH状态: ${翻译值.checking}
${翻译值.regionMatch}${翻译值.checking}
${翻译值.selectionLogic}${翻译值.selectionLogicText}
${翻译值.configManagement}
${翻译值.kvStatusChecking}
${翻译值.advancedControl}
${翻译值.loading}
${翻译值.currentConfig}
${翻译值.checking}
`;
return new Response(值页面, {
status: 200,
headers: {
'Content-Type': 'text/html; charset=utf-8'
}
});
}
async function 解析木马头部(缓冲234, 本地值233) {
const 字节 = 处理值值8数组(缓冲234);
const 密码值井号 = 传输路径 || 本地值233;
const 值224密码 = await 处理值224井号(密码值井号);
if (字节.byteLength < 56) {
return {
hasError: true,
message: "invalid " + atob('dHJvamFu') + " data - too short"
};
}
let 值值索引 = 56;
if (字节[56] !== 0x0d || 字节[57] !== 0x0a) {
return {
hasError: true,
message: "invalid " + atob('dHJvamFu') + " header format (missing CR LF)"
};
}
const 密码232 = 共享解码器.decode(字节.subarray(0, 值值索引));
if (密码232 !== 值224密码) {
return {
hasError: true,
message: "invalid " + atob('dHJvamFu') + " password"
};
}
const 代理5数据缓冲 = 字节.subarray(值值索引 + 2);
if (代理5数据缓冲.byteLength < 6) {
return {
hasError: true,
message: atob('aW52YWxpZCBTT0NLUzUgcmVxdWVzdCBkYXRh')
};
}
const 视图231 = new DataView(代理5数据缓冲.buffer, 代理5数据缓冲.byteOffset, 代理5数据缓冲.byteLength);
const 命令230 = 视图231.getUint8(0);
if (命令230 !== 1) {
return {
hasError: true,
message: "unsupported command, only TCP (CONNECT) is allowed"
};
}
const 本地值229 = 视图231.getUint8(1);
let 地址长度 = 0;
let 地址索引228 = 2;
let 地址227 = "";
switch (本地值229) {
case 1:
地址长度 = 4;
地址227 = 代理5数据缓冲.subarray(地址索引228, 地址索引228 + 地址长度).join(".");
break;
case 3:
地址长度 = 代理5数据缓冲[地址索引228];
地址索引228 += 1;
地址227 = 共享解码器.decode(代理5数据缓冲.subarray(地址索引228, 地址索引228 + 地址长度));
break;
case 4:
地址长度 = 16;
const 数据视图 = new DataView(代理5数据缓冲.buffer, 代理5数据缓冲.byteOffset + 地址索引228, 地址长度);
const 值6 = [];
for (let 索引值226 = 0; 索引值226 < 8; 索引值226++) {
值6.push(数据视图.getUint16(索引值226 * 2).toString(16));
}
地址227 = 值6.join(":");
break;
default:
return {
hasError: true,
message: `invalid addressType is ${本地值229}`
};
}
if (!地址227) {
return {
hasError: true,
message: `address is empty, addressType is ${本地值229}`
};
}
const 端口索引225 = 地址索引228 + 地址长度;
const 端口远程 = new DataView(代理5数据缓冲.buffer, 代理5数据缓冲.byteOffset + 端口索引225, 2).getUint16(0);
return {
hasError: false,
addressRemote: 地址227,
addressType: 本地值229,
port: 端口远程,
hostname: 地址227,
rawClientData: 代理5数据缓冲.subarray(端口索引225 + 4)
};
}
async function 处理值224井号(文本224) {
const 编码器 = new TextEncoder();
const 数据223 = 编码器.encode(文本224);
const 本地值222 = [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];
let 头部游标 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
const 消息长度 = 数据223.length;
const 值长度221 = 消息长度 * 8;
const 值长度220 = Math.ceil((消息长度 + 9) / 64) * 64;
const 本地值219 = new Uint8Array(值长度220);
本地值219.set(数据223);
本地值219[消息长度] = 0x80;
const 视图 = new DataView(本地值219.buffer);
视图.setUint32(值长度220 - 4, 值长度221, false);
for (let 块218 = 0; 块218 < 值长度220; 块218 += 64) {
const 写入器包装 = new Uint32Array(64);
for (let 索引值217 = 0; 索引值217 < 16; 索引值217++) {
写入器包装[索引值217] = 视图.getUint32(块218 + 索引值217 * 4, false);
}
for (let 索引值216 = 16; 索引值216 < 64; 索引值216++) {
const 值0215 = 处理值值200(写入器包装[索引值216 - 15], 7) ^ 处理值值200(写入器包装[索引值216 - 15], 18) ^ 写入器包装[索引值216 - 15] >>> 3;
const 值1214 = 处理值值200(写入器包装[索引值216 - 2], 17) ^ 处理值值200(写入器包装[索引值216 - 2], 19) ^ 写入器包装[索引值216 - 2] >>> 10;
写入器包装[索引值216] = 写入器包装[索引值216 - 16] + 值0215 + 写入器包装[索引值216 - 7] + 值1214 >>> 0;
}
let [甲值213, 乙值, 丙值212, 丁值211, 事件值210, 表单值, 本地值209, 头值208] = 头部游标;
for (let 索引值207 = 0; 索引值207 < 64; 索引值207++) {
const 值1206 = 处理值值200(事件值210, 6) ^ 处理值值200(事件值210, 11) ^ 处理值值200(事件值210, 25);
const 本地值205 = 事件值210 & 表单值 ^ ~事件值210 & 本地值209;
const 值1 = 头值208 + 值1206 + 本地值205 + 本地值222[索引值207] + 写入器包装[索引值207] >>> 0;
const 值0 = 处理值值200(甲值213, 2) ^ 处理值值200(甲值213, 13) ^ 处理值值200(甲值213, 22);
const 本地值204 = 甲值213 & 乙值 ^ 甲值213 & 丙值212 ^ 乙值 & 丙值212;
const 值2203 = 值0 + 本地值204 >>> 0;
头值208 = 本地值209;
本地值209 = 表单值;
表单值 = 事件值210;
事件值210 = 丁值211 + 值1 >>> 0;
丁值211 = 丙值212;
丙值212 = 乙值;
乙值 = 甲值213;
甲值213 = 值1 + 值2203 >>> 0;
}
头部游标[0] = 头部游标[0] + 甲值213 >>> 0;
头部游标[1] = 头部游标[1] + 乙值 >>> 0;
头部游标[2] = 头部游标[2] + 丙值212 >>> 0;
头部游标[3] = 头部游标[3] + 丁值211 >>> 0;
头部游标[4] = 头部游标[4] + 事件值210 >>> 0;
头部游标[5] = 头部游标[5] + 表单值 >>> 0;
头部游标[6] = 头部游标[6] + 本地值209 >>> 0;
头部游标[7] = 头部游标[7] + 头值208 >>> 0;
}
const 结果202 = [];
for (let 索引值201 = 0; 索引值201 < 7; 索引值201++) {
结果202.push((头部游标[索引值201] >>> 24 & 0xff).toString(16).padStart(2, '0'), (头部游标[索引值201] >>> 16 & 0xff).toString(16).padStart(2, '0'), (头部游标[索引值201] >>> 8 & 0xff).toString(16).padStart(2, '0'), (头部游标[索引值201] & 0xff).toString(16).padStart(2, '0'));
}
return 结果202.join('');
}
function 处理值值200(值199, 本地值198) {
return 值199 >>> 本地值198 | 值199 << 32 - 本地值198;
}
let 值值197 = 0;
const 值超文本缓冲大小 = 128 * 1024;
const 连接超时值 = 5000;
const 值超时值 = 45000;
const 上限值196 = 2;
const 上限值 = 32;
function 处理扩展超文本值195(本地值194) {
return new Promise(结果值193 => setTimeout(结果值193, 本地值194));
}
function 验证唯一标识扩展超文本(标识192, 唯一标识191) {
for (let 索引190 = 0; 索引190 < 16; 索引190++) {
if (标识192[索引190] !== 唯一标识191[索引190]) {
return false;
}
}
return true;
}
class 扩展超文本计数器 {
#total;
constructor() {
this.#total = 0;
}
get() {
return this.#total;
}
add(大小189) {
this.#total += 大小189;
}
}
function 处理值值值(首次, ...本地值188) {
let 长度 = 首次.length;
for (let 甲值187 of 本地值188) {
长度 += 甲值187.length;
}
const 结果值186 = new 首次.constructor(长度);
结果值186.set(首次, 0);
长度 = 首次.length;
for (let 甲值185 of 本地值188) {
结果值186.set(甲值185, 长度);
长度 += 甲值185.length;
}
return 结果值186;
}
function 解析唯一标识扩展超文本(唯一标识184) {
唯一标识184 = 唯一标识184.replaceAll('-', '');
const 结果值183 = [];
for (let 索引182 = 0; 索引182 < 16; 索引182++) {
const 取值181 = parseInt(唯一标识184.substr(索引182 * 2, 2), 16);
结果值183.push(取值181);
}
return 结果值183;
}
function 获取扩展超文本缓冲(大小) {
return new Uint8Array(new ArrayBuffer(大小 || 值超文本缓冲大小));
}
async function 读取扩展超文本头部(本地值180, 唯一标识字符串) {
const 读取器179 = 本地值180.getReader({
mode: 'byob'
});
try {
let 结果值178 = await 读取器179.readAtLeast(1 + 16 + 1, 获取扩展超文本缓冲());
let 本地值177 = 0;
let 索引 = 0;
let 缓存 = 结果值178.value;
本地值177 += 结果值178.value.length;
const 本地值176 = 缓存[0];
const 标识175 = 缓存.slice(1, 1 + 16);
const 唯一标识174 = 解析唯一标识扩展超文本(唯一标识字符串);
if (!验证唯一标识扩展超文本(标识175, 唯一标识174)) {
return `invalid UUID`;
}
const 值长度173 = 缓存[1 + 16];
const 地址值1 = 1 + 16 + 1 + 值长度173 + 1 + 2 + 1;
if (地址值1 + 1 > 本地值177) {
if (结果值178.done) {
return `header too short`;
}
索引 = 地址值1 + 1 - 本地值177;
结果值178 = await 读取器179.readAtLeast(索引, 获取扩展超文本缓冲());
本地值177 += 结果值178.value.length;
缓存 = 处理值值值(缓存, 结果值178.value);
}
const 命令 = 缓存[1 + 16 + 1 + 值长度173];
if (命令 !== 1) {
return `unsupported command: ${命令}`;
}
const 端口172 = (缓存[地址值1 - 1 - 2] << 8) + 缓存[地址值1 - 1 - 1];
const 本地值171 = 缓存[地址值1 - 1];
let 头部长度 = -1;
if (本地值171 === 地址类型_四版) {
头部长度 = 地址值1 + 4;
} else if (本地值171 === 地址类型_六版) {
头部长度 = 地址值1 + 16;
} else if (本地值171 === 地址类型_网址) {
头部长度 = 地址值1 + 1 + 缓存[地址值1];
}
if (头部长度 < 0) {
return 'read address type failed';
}
索引 = 头部长度 - 本地值177;
if (索引 > 0) {
if (结果值178.done) {
return `read address failed`;
}
结果值178 = await 读取器179.readAtLeast(索引, 获取扩展超文本缓冲());
本地值177 += 结果值178.value.length;
缓存 = 处理值值值(缓存, 结果值178.value);
}
let 主机名170 = '';
索引 = 地址值1;
switch (本地值171) {
case 地址类型_四版:
主机名170 = 缓存.slice(索引, 索引 + 4).join('.');
break;
case 地址类型_网址:
主机名170 = new TextDecoder().decode(缓存.slice(索引 + 1, 索引 + 1 + 缓存[索引]));
break;
case 地址类型_六版:
主机名170 = 缓存.slice(索引, 索引 + 16).reduce((字符串值, 值2169, 值2, 甲值) => 值2 % 2 ? 字符串值.concat(((甲值[值2 - 1] << 8) + 值2169).toString(16)) : 字符串值, []).join(':');
break;
}
if (主机名170.length < 1) {
return 'failed to parse hostname';
}
const 数据 = 缓存.slice(头部长度);
return {
hostname: 主机名170,
port: 端口172,
data: 数据,
resp: new Uint8Array([本地值176, 0]),
reader: 读取器179,
done: 结果值178.done
};
} catch (错误168) {
try {
读取器179.releaseLock();
} catch (忽略值167) {}
throw 错误168;
}
}
async function 处理值值远程扩展超文本(计数器166, 写入器165, 本地值164) {
async function 处理值值(丁值) {
if (!丁值 || 丁值.length === 0) {
return;
}
计数器166.add(丁值.length);
try {
await 写入器165.write(丁值);
} catch (错误163) {
throw 错误163;
}
}
try {
await 处理值值(本地值164.data);
let 块数量162 = 0;
while (!本地值164.done) {
const 结果值161 = await 本地值164.reader.read(获取扩展超文本缓冲());
if (结果值161.done) break;
await 处理值值(结果值161.value);
本地值164.done = 结果值161.done;
块数量162++;
if (块数量162 % 10 === 0) {
await 处理扩展超文本值195(0);
}
if (!结果值161.value || 结果值161.value.length === 0) {
await 处理扩展超文本值195(2);
}
}
} catch (错误160) {
throw 错误160;
}
}
function 创建扩展超文本值159(本地值158, 本地值157) {
const 计数器156 = new 扩展超文本计数器();
const 写入器155 = 本地值157.getWriter();
const 本地值154 = (async () => {
try {
await 处理值值远程扩展超文本(计数器156, 写入器155, 本地值158);
} catch (错误153) {
throw 错误153;
} finally {
try {
await 写入器155.close();
} catch (错误152) {}
}
})();
return {
counter: 计数器156,
done: 本地值154,
abort: () => {
try {
写入器155.abort();
} catch (忽略值151) {}
}
};
}
function 创建扩展超文本值(本地值150, 远程值) {
const 计数器 = new 扩展超文本计数器();
let 流;
const 本地值149 = new Promise((本地值148, 本地值147) => {
流 = new TransformStream({
start(控制器146) {
计数器.add(本地值150.length);
控制器146.enqueue(本地值150);
},
transform(块, 控制器145) {
计数器.add(块.length);
控制器145.enqueue(块);
},
cancel(本地值144) {
本地值147(`download cancelled: ${本地值144}`);
}
}, null, new ByteLengthQueuingStrategy({
highWaterMark: 值超文本缓冲大小
}));
let 值值143 = Date.now();
const 值计时器 = setInterval(() => {
if (Date.now() - 值值143 > 值超时值) {
try {
流.writable.abort?.('idle timeout');
} catch (忽略值142) {}
clearInterval(值计时器);
本地值147('idle timeout');
}
}, 5000);
const 读取器 = 远程值.getReader();
const 写入器 = 流.writable.getWriter();
;
(async () => {
try {
let 块数量 = 0;
while (true) {
const 结果值141 = await 读取器.read();
if (结果值141.done) {
break;
}
值值143 = Date.now();
await 写入器.write(结果值141.value);
块数量++;
if (块数量 % 5 === 0) {
await 处理扩展超文本值195(0);
}
}
await 写入器.close();
本地值148();
} catch (错误140) {
本地值147(错误140);
} finally {
try {
读取器.releaseLock();
} catch (忽略值139) {}
try {
写入器.releaseLock();
} catch (忽略值138) {}
clearInterval(值计时器);
}
})();
});
return {
readable: 流.readable,
counter: 计数器,
done: 本地值149,
abort: () => {
try {
流.readable.cancel();
} catch (忽略值137) {}
try {
流.writable.abort();
} catch (忽略值136) {}
}
};
}
async function 连接值远程扩展超文本(本地值135, ...本地值134) {
let 本地值133 = 0;
let 值错误;
const 连接列表 = [本地值135.hostname, ...本地值134.filter(结果值 => 结果值 && 结果值 !== 本地值135.hostname)];
for (const 主机名 of 连接列表) {
if (!主机名) continue;
本地值133 = 0;
while (本地值133 < 上限值196) {
本地值133++;
try {
const 远程 = 连接({
hostname: 主机名,
port: 本地值135.port
});
const 超时承诺 = 处理扩展超文本值195(连接超时值).then(() => {
throw new Error(atob('Y29ubmVjdCB0aW1lb3V0'));
});
await Promise.race([远程.opened, 超时承诺]);
const 本地值132 = 创建扩展超文本值159(本地值135, 远程.writable);
const 本地值131 = 创建扩展超文本值(本地值135.resp, 远程.readable);
return {
downloader: 本地值131,
uploader: 本地值132,
close: () => {
try {
远程.close();
} catch (忽略值130) {}
}
};
} catch (错误129) {
值错误 = 错误129;
if (本地值133 < 上限值196) {
await 处理扩展超文本值195(500 * 本地值133);
}
}
}
}
return null;
}
async function 处理扩展超文本客户端(主体128, 唯一标识) {
if (值值197 >= 上限值) {
return new Response('Too many connections', {
status: 429
});
}
值值197++;
let 本地值127 = false;
const 本地值126 = () => {
if (!本地值127) {
值值197 = Math.max(0, 值值197 - 1);
本地值127 = true;
}
};
try {
const 本地值125 = await 读取扩展超文本头部(主体128, 唯一标识);
if (typeof 本地值125 !== 'object' || !本地值125) {
return null;
}
const 远程连接 = await 连接值远程扩展超文本(本地值125, 回退地址, '13.230.34.30');
if (远程连接 === null) {
return null;
}
const 连接值 = Promise.race([(async () => {
try {
await 远程连接.downloader.done;
} catch (错误124) {}
})(), (async () => {
try {
await 远程连接.uploader.done;
} catch (错误123) {}
})(), 处理扩展超文本值195(值超时值).then(() => {})]).finally(() => {
try {
远程连接.close();
} catch (忽略值122) {}
try {
远程连接.downloader.abort();
} catch (忽略值121) {}
try {
远程连接.uploader.abort();
} catch (忽略值) {}
本地值126();
});
return {
readable: 远程连接.downloader.readable,
closed: 连接值
};
} catch (错误120) {
本地值126();
return null;
}
}
async function 处理扩展超文本值(请求119) {
try {
return await 处理扩展超文本客户端(请求119.body, 认证令牌);
} catch (错误118) {
return null;
}
}
function 处理基础64值数组(值64字符串) {
if (!值64字符串) return {
error: null
};
try {
值64字符串 = 值64字符串.replace(/-/g, '+').replace(/_/g, '/');
return {
earlyData: Uint8Array.from(atob(值64字符串), 丙值117 => 丙值117.charCodeAt(0)).buffer,
error: null
};
} catch (错误116) {
return {
error: 错误116
};
}
}
function 关闭套接字值(套接字) {
try {
if (套接字.readyState === 1 || 套接字.readyState === 2) 套接字.close();
} catch (错误115) {}
}
const 十六进制值 = Array.from({
length: 256
}, (取值, 索引值) => (索引值 + 256).toString(16).slice(1));
function 处理格式值(本地值114, 偏移 = 0) {
const 标识 = (十六进制值[本地值114[偏移]] + 十六进制值[本地值114[偏移 + 1]] + 十六进制值[本地值114[偏移 + 2]] + 十六进制值[本地值114[偏移 + 3]] + "-" + 十六进制值[本地值114[偏移 + 4]] + 十六进制值[本地值114[偏移 + 5]] + "-" + 十六进制值[本地值114[偏移 + 6]] + 十六进制值[本地值114[偏移 + 7]] + "-" + 十六进制值[本地值114[偏移 + 8]] + 十六进制值[本地值114[偏移 + 9]] + "-" + 十六进制值[本地值114[偏移 + 10]] + 十六进制值[本地值114[偏移 + 11]] + 十六进制值[本地值114[偏移 + 12]] + 十六进制值[本地值114[偏移 + 13]] + 十六进制值[本地值114[偏移 + 14]] + 十六进制值[本地值114[偏移 + 15]]).toLowerCase();
if (!是否有效格式(标识)) throw new TypeError(错误_无效标识字符串);
return 标识;
}
async function 获取值解析新地址列表() {
const 网址113 = 优选地址源;
try {
const 网址列表112 = 网址113.includes(',') ? 网址113.split(',').map(网址值111 => 网址值111.trim()).filter(网址值 => 网址值) : [网址113];
const 接口结果列表 = await 获取优选接口(网址列表112, '443', 5000);
if (接口结果列表.length > 0) {
const 结果列表110 = [];
const 正则 = /^(\[[\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+))?(?:#(.+))?$/;
for (const 项目109 of 接口结果列表) {
const 本地值108 = 项目109.match(正则);
if (本地值108) {
结果列表110.push({
ip: 本地值108[1],
port: parseInt(本地值108[2] || '443', 10),
name: 本地值108[3]?.trim() || 本地值108[1]
});
}
}
return 结果列表110;
}
const 响应107 = await fetch(网址113);
if (!响应107.ok) return [];
const 文本106 = await 响应107.text();
const 结果列表105 = [];
const 行列表104 = 文本106.trim().replace(/\r/g, "").split('\n');
const 值正则 = /^([^:]+):(\d+)#(.*)$/;
for (const 行103 of 行列表104) {
const 值行 = 行103.trim();
if (!值行) continue;
const 本地值102 = 值行.match(值正则);
if (本地值102) {
结果列表105.push({
ip: 本地值102[1],
port: parseInt(本地值102[2], 10),
name: 本地值102[3].trim() || 本地值102[1]
});
}
}
return 结果列表105;
} catch (错误101) {
return [];
}
}
function 生成链接列表来源新地址列表(列表100, 用户99, 工作器域名98, 加密客户端问候配置97 = null, 跳过编号96 = false, 别名命名器95 = null) {
const 云墙超文本端口94 = [80, 8080, 8880, 2052, 2082, 2086, 2095];
const 云墙安全超文本端口93 = [443, 2053, 2083, 2087, 2096, 8443];
const 链接列表92 = [];
const 网页套接字路径91 = '/?ed=2048';
const 协议 = atob('dmxlc3M=');
const 制作节点名称90 = 别名命名器95 || 创建值节点命名器(跳过编号96);
for (const 项目89 of 列表100) {
const 端口88 = 项目89.port;
const 安全地址87 = 项目89.ip.includes(':') ? `[${项目89.ip}]` : 项目89.ip;
if (云墙安全超文本端口93.includes(端口88)) {
const 网页套接字节点名称86 = 制作节点名称90(项目89);
let 链接85 = `${协议}://${用户99}@${安全地址87}:${端口88}?encryption=none&security=tls&sni=${工作器域名98}&fp=${启用加密客户端问候 ? 'chrome' : 'randomized'}&type=ws&host=${工作器域名98}&path=${网页套接字路径91}`;
if (自定义应用层协议协商) 链接85 += `&alpn=${encodeURIComponent(自定义应用层协议协商)}`;
// 如果启用了ECH，添加ech参数（ECH需要伪装成Chrome浏览器）
if (启用加密客户端问候) {
const 域名系统值84 = 自定义域名系统 || 'https://223.5.5.5/dns-query';
const 加密客户端问候域名83 = 自定义加密客户端问候域名 || 'cloudflare-ech.com';
链接85 += `&ech=${encodeURIComponent(`${加密客户端问候域名83}+${域名系统值84}`)}`;
}
链接85 += `#${encodeURIComponent(网页套接字节点名称86)}`;
链接列表92.push(链接85);
} else if (云墙超文本端口94.includes(端口88)) {
if (!禁用非传输层安全) {
const 网页套接字节点名称82 = 制作节点名称90(项目89);
const 链接81 = `${协议}://${用户99}@${安全地址87}:${端口88}?encryption=none&security=none&type=ws&host=${工作器域名98}&path=${网页套接字路径91}#${encodeURIComponent(网页套接字节点名称82)}`;
链接列表92.push(链接81);
}
} else {
const 网页套接字节点名称80 = 制作节点名称90(项目89);
let 链接79 = `${协议}://${用户99}@${安全地址87}:${端口88}?encryption=none&security=tls&sni=${工作器域名98}&fp=${启用加密客户端问候 ? 'chrome' : 'randomized'}&type=ws&host=${工作器域名98}&path=${网页套接字路径91}`;
if (自定义应用层协议协商) 链接79 += `&alpn=${encodeURIComponent(自定义应用层协议协商)}`;
// 如果启用了ECH，添加ech参数（ECH需要伪装成Chrome浏览器）
if (启用加密客户端问候) {
const 域名系统值78 = 自定义域名系统 || 'https://223.5.5.5/dns-query';
const 加密客户端问候域名77 = 自定义加密客户端问候域名 || 'cloudflare-ech.com';
链接79 += `&ech=${encodeURIComponent(`${加密客户端问候域名77}+${域名系统值78}`)}`;
}
链接79 += `#${encodeURIComponent(网页套接字节点名称80)}`;
链接列表92.push(链接79);
}
}
return 链接列表92;
}
function 生成扩展超文本链接列表来源源(列表76, 用户75, 工作器域名74, 加密客户端问候配置73 = null, 跳过编号72 = false, 别名命名器71 = null) {
const 链接列表70 = [];
const 节点路径 = 用户75.substring(0, 8);
const 制作节点名称69 = 别名命名器71 || 创建值节点命名器(跳过编号72);
for (const 项目68 of 列表76) {
const 安全地址67 = 项目68.ip.includes(':') ? `[${项目68.ip}]` : 项目68.ip;
const 端口66 = 项目68.port || 443;
const 网页套接字节点名称65 = 制作节点名称69(项目68);
const 参数 = new URLSearchParams({
encryption: 'none',
security: 'tls',
sni: 工作器域名74,
fp: 'chrome',
type: 'xhttp',
host: 工作器域名74,
path: `/${节点路径}`,
mode: 'stream-one'
});
处理值应用层协议协商值(参数);
if (启用加密客户端问候) {
const 域名系统值64 = 自定义域名系统 || 'https://223.5.5.5/dns-query';
const 加密客户端问候域名63 = 自定义加密客户端问候域名 || 'cloudflare-ech.com';
参数.set('ech', `${加密客户端问候域名63}+${域名系统值64}`);
}
链接列表70.push(`${解码64('dmxlc3M6Ly8=')}${用户75}@${安全地址67}:${端口66}?${参数.toString()}#${encodeURIComponent(网页套接字节点名称65)}`);
}
return 链接列表70;
}
async function 生成木马链接列表来源新地址列表(列表, 用户, 工作器域名, 加密客户端问候配置 = null, 跳过编号 = false, 别名命名器 = null) {
const 云墙超文本端口 = [80, 8080, 8880, 2052, 2082, 2086, 2095];
const 云墙安全超文本端口 = [443, 2053, 2083, 2087, 2096, 8443];
const 链接列表 = [];
const 网页套接字路径 = '/?ed=2048';
const 密码 = 传输路径 || 用户;
const 制作节点名称 = 别名命名器 || 创建值节点命名器(跳过编号);
for (const 项目62 of 列表) {
const 端口61 = 项目62.port;
const 安全地址 = 项目62.ip.includes(':') ? `[${项目62.ip}]` : 项目62.ip;
if (云墙安全超文本端口.includes(端口61)) {
const 网页套接字节点名称60 = 制作节点名称(项目62);
let 链接59 = `${atob('dHJvamFuOi8v')}${密码}@${安全地址}:${端口61}?security=tls&sni=${工作器域名}&fp=chrome&type=ws&host=${工作器域名}&path=${网页套接字路径}`;
if (自定义应用层协议协商) 链接59 += `&alpn=${encodeURIComponent(自定义应用层协议协商)}`;
// 如果启用了ECH，添加ech参数（ECH需要伪装成Chrome浏览器）
if (启用加密客户端问候) {
const 域名系统值58 = 自定义域名系统 || 'https://223.5.5.5/dns-query';
const 加密客户端问候域名57 = 自定义加密客户端问候域名 || 'cloudflare-ech.com';
链接59 += `&ech=${encodeURIComponent(`${加密客户端问候域名57}+${域名系统值58}`)}`;
}
链接59 += `#${encodeURIComponent(网页套接字节点名称60)}`;
链接列表.push(链接59);
} else if (云墙超文本端口.includes(端口61)) {
if (!禁用非传输层安全) {
const 网页套接字节点名称56 = 制作节点名称(项目62);
const 链接55 = `${atob('dHJvamFuOi8v')}${密码}@${安全地址}:${端口61}?security=none&type=ws&host=${工作器域名}&path=${网页套接字路径}#${encodeURIComponent(网页套接字节点名称56)}`;
链接列表.push(链接55);
}
} else {
const 网页套接字节点名称 = 制作节点名称(项目62);
let 链接 = `${atob('dHJvamFuOi8v')}${密码}@${安全地址}:${端口61}?security=tls&sni=${工作器域名}&fp=chrome&type=ws&host=${工作器域名}&path=${网页套接字路径}`;
if (自定义应用层协议协商) 链接 += `&alpn=${encodeURIComponent(自定义应用层协议协商)}`;
// 如果启用了ECH，添加ech参数（ECH需要伪装成Chrome浏览器）
if (启用加密客户端问候) {
const 域名系统值 = 自定义域名系统 || 'https://223.5.5.5/dns-query';
const 加密客户端问候域名 = 自定义加密客户端问候域名 || 'cloudflare-ech.com';
链接 += `&ech=${encodeURIComponent(`${加密客户端问候域名}+${域名系统值}`)}`;
}
链接 += `#${encodeURIComponent(网页套接字节点名称)}`;
链接列表.push(链接);
}
}
return 链接列表;
}
async function 处理配置接口(请求54, 环境值 = {}) {
if (请求54.method === 'GET') {
if (!键值存储) {
return new Response(JSON.stringify({
error: 'KV存储未配置',
kvEnabled: false
}), {
status: 503,
headers: {
'Content-Type': 'application/json'
}
});
}
return new Response(JSON.stringify({
...获取有效配置快照(环境值),
kvEnabled: true
}), {
headers: {
'Content-Type': 'application/json'
}
});
} else if (请求54.method === 'POST') {
if (!键值存储) {
return new Response(JSON.stringify({
success: false,
message: 'KV存储未配置，无法保存配置'
}), {
status: 503,
headers: {
'Content-Type': 'application/json'
}
});
}
try {
const 新配置 = await 请求54.json();
for (const [键, 值] of Object.entries(新配置)) {
if (值 === '' || 值 === null || 值 === undefined) {
delete 键值配置[键];
} else {
键值配置[键] = 值;
}
}
await 保存键值配置();
更新配置值();
if (新配置.yx !== undefined) {
更新自定义优选来源值();
}
return new Response(JSON.stringify({
success: true,
message: '配置已保存',
config: 获取有效配置快照(环境值)
}), {
headers: {
'Content-Type': 'application/json'
}
});
} catch (错误53) {
return new Response(JSON.stringify({
success: false,
message: '保存配置失败: ' + 错误53.message
}), {
status: 500,
headers: {
'Content-Type': 'application/json'
}
});
}
}
return new Response(JSON.stringify({
error: 'Method not allowed'
}), {
status: 405,
headers: {
'Content-Type': 'application/json'
}
});
}
async function 处理优选地址列表接口(请求) {
if (!键值存储) {
return new Response(JSON.stringify({
success: false,
error: 'KV存储未配置',
message: '需要配置KV存储才能使用此功能'
}), {
status: 503,
headers: {
'Content-Type': 'application/json'
}
});
}
const 本地值52 = 获取配置值('ae', '') === 'yes';
if (!本地值52) {
return new Response(JSON.stringify({
success: false,
error: 'API功能未启用',
message: '出于安全考虑，优选IP API功能默认关闭。请在配置管理页面开启"允许API管理"选项后使用。'
}), {
status: 403,
headers: {
'Content-Type': 'application/json'
}
});
}
try {
if (请求.method === 'GET') {
const 值值51 = 获取配置值('yx', '');
const 本地值50 = 解析值值数组(值值51);
return new Response(JSON.stringify({
success: true,
count: 本地值50.length,
data: 本地值50
}), {
headers: {
'Content-Type': 'application/json'
}
});
} else if (请求.method === 'POST') {
const 主体49 = await 请求.json();
const 地址列表值添加 = Array.isArray(主体49) ? 主体49 : [主体49];
if (地址列表值添加.length === 0) {
return new Response(JSON.stringify({
success: false,
error: '请求数据为空',
message: '请提供IP数据'
}), {
status: 400,
headers: {
'Content-Type': 'application/json'
}
});
}
const 值值48 = 获取配置值('yx', '');
let 本地值47 = 解析值值数组(值值48);
const 值地址列表46 = [];
const 值地址列表45 = [];
const 错误列表 = [];
for (const 项目44 of 地址列表值添加) {
if (!项目44.ip) {
错误列表.push({
ip: '未知',
reason: 'IP地址是必需的'
});
continue;
}
const 端口43 = 项目44.port || 443;
const 名称 = 项目44.name || `API优选-${项目44.ip}:${端口43}`;
if (!是否有效地址(项目44.ip) && !是否有效域名(项目44.ip)) {
错误列表.push({
ip: 项目44.ip,
reason: '无效的IP或域名格式'
});
continue;
}
const 本地值42 = 本地值47.some(值项目 => 值项目.ip === 项目44.ip && 值项目.port === 端口43);
if (本地值42) {
值地址列表45.push({
ip: 项目44.ip,
port: 端口43,
reason: '已存在'
});
continue;
}
const 新地址 = {
ip: 项目44.ip,
port: 端口43,
name: 名称,
addedAt: new Date().toISOString()
};
本地值47.push(新地址);
值地址列表46.push(新地址);
}
if (值地址列表46.length > 0) {
const 新值值41 = 处理数组值值(本地值47);
await 设置配置值('yx', 新值值41);
更新自定义优选来源值();
}
return new Response(JSON.stringify({
success: 值地址列表46.length > 0,
message: `成功添加 ${值地址列表46.length} 个IP`,
added: 值地址列表46.length,
skipped: 值地址列表45.length,
errors: 错误列表.length,
data: {
addedIPs: 值地址列表46,
skippedIPs: 值地址列表45.length > 0 ? 值地址列表45 : undefined,
errors: 错误列表.length > 0 ? 错误列表 : undefined
}
}), {
headers: {
'Content-Type': 'application/json'
}
});
} else if (请求.method === 'DELETE') {
const 主体 = await 请求.json();
if (主体.all === true) {
const 值值40 = 获取配置值('yx', '');
const 本地值39 = 解析值值数组(值值40);
const 值数量 = 本地值39.length;
await 设置配置值('yx', '');
更新自定义优选来源值();
return new Response(JSON.stringify({
success: true,
message: `已清空所有优选IP，共删除 ${值数量} 个`,
deletedCount: 值数量
}), {
headers: {
'Content-Type': 'application/json'
}
});
}
if (!主体.ip) {
return new Response(JSON.stringify({
success: false,
error: 'IP地址是必需的',
message: '请提供要删除的ip字段，或使用 {"all": true} 清空所有'
}), {
status: 400,
headers: {
'Content-Type': 'application/json'
}
});
}
const 端口38 = 主体.port || 443;
const 值值37 = 获取配置值('yx', '');
let 本地值36 = 解析值值数组(值值37);
const 值长度 = 本地值36.length;
const 值地址列表 = 本地值36.filter(项目35 => !(项目35.ip === 主体.ip && 项目35.port === 端口38));
if (值地址列表.length === 值长度) {
return new Response(JSON.stringify({
success: false,
error: '优选IP不存在',
message: `${主体.ip}:${端口38} 未找到`
}), {
status: 404,
headers: {
'Content-Type': 'application/json'
}
});
}
const 新值值 = 处理数组值值(值地址列表);
await 设置配置值('yx', 新值值);
更新自定义优选来源值();
return new Response(JSON.stringify({
success: true,
message: '优选IP已删除',
deleted: {
ip: 主体.ip,
port: 端口38
}
}), {
headers: {
'Content-Type': 'application/json'
}
});
} else {
return new Response(JSON.stringify({
success: false,
error: '不支持的请求方法',
message: '支持的方法: GET, POST, DELETE'
}), {
status: 405,
headers: {
'Content-Type': 'application/json'
}
});
}
} catch (错误34) {
return new Response(JSON.stringify({
success: false,
error: '处理请求失败',
message: 错误34.message
}), {
status: 500,
headers: {
'Content-Type': 'application/json'
}
});
}
}
function 更新配置值() {
const 有效配置 = 获取有效配置快照();
const 手动地区 = 有效配置.wk;
if (手动地区 && 手动地区.trim()) {
手动工作器地区 = 手动地区.trim().toUpperCase();
当前工作器地区 = 手动工作器地区;
} else {
const 本地值 = 有效配置.p;
if (本地值 && 本地值.trim()) {
当前工作器地区 = 'CUSTOM';
} else {
手动工作器地区 = '';
当前工作器地区 = '';
}
}
启用地区匹配 = !(有效配置.rm && 有效配置.rm.toLowerCase() === 'no');
启用明文 = 有效配置.ev === 'yes';
启用木马 = 有效配置.et === 'yes';
启用扩展传输 = 有效配置.ex === 'yes';
传输路径 = 有效配置.tp || '';
订阅转换接口 = 有效配置.scu || 配置默认值.scu;
启用优选域名 = 有效配置.epd === 'yes';
启用优选地址 = 有效配置.epi === 'yes';
启用仓库优选 = 有效配置.egi === 'yes';
启用原生地址 = 有效配置.ena === 'yes';
启用加密客户端问候 = 有效配置.ech === 'yes';
自定义域名系统 = 有效配置.customDNS || 配置默认值.customDNS;
自定义加密客户端问候域名 = 有效配置.customECHDomain || 配置默认值.customECHDomain;
自定义应用层协议协商 = 规范化应用层协议协商(有效配置.alpn || '');
禁用非传输层安全 = 有效配置.dkby === 'yes' || 启用加密客户端问候;
启用代理降级 = !!(有效配置.qj && 有效配置.qj.toLowerCase() === 'no');
自定义路径 = 有效配置.d || '';
优选地址源 = 有效配置.yxURL || '';
回退地址 = 有效配置.p ? 有效配置.p.trim() : '';
代理5配置 = 有效配置.s || '';
if (代理5配置) {
try {
已解析代理5配置 = 解析代理配置(代理5配置);
是否代理已启用 = true;
} catch (错误31) {
是否代理已启用 = false;
}
} else {
已解析代理5配置 = {};
是否代理已启用 = false;
}
禁用优选 = !!(有效配置.yxby && 有效配置.yxby.toLowerCase() === 'yes');
}
function 更新自定义优选来源值() {
const 值值30 = 获取配置值('yx', '');
if (值值30) {
try {
const 优选列表 = 值值30.split(',').map(项目29 => 项目29.trim()).filter(项目28 => 项目28);
自定义优选地址列表 = [];
自定义优选域名列表 = [];
优选列表.forEach(项目27 => {
let 节点名称26 = '';
let 地址部分25 = 项目27;
if (项目27.includes('#')) {
const 部分列表24 = 项目27.split('#');
地址部分25 = 部分列表24[0].trim();
节点名称26 = 部分列表24[1].trim();
}
const {
address: 地址23,
port: 端口22
} = 解析地址值端口(地址部分25);
if (!节点名称26) {
节点名称26 = '自定义优选-' + 地址23 + (端口22 ? ':' + 端口22 : '');
}
if (是否有效地址(地址23)) {
自定义优选地址列表.push({
ip: 地址23,
port: 端口22,
isp: 节点名称26
});
} else {
自定义优选域名列表.push({
domain: 地址23,
port: 端口22,
name: 节点名称26
});
}
});
} catch (错误) {
自定义优选地址列表 = [];
自定义优选域名列表 = [];
}
} else {
自定义优选地址列表 = [];
自定义优选域名列表 = [];
}
}
function 解析值值数组(值值) {
if (!值值 || !值值.trim()) return [];
const 项目列表 = 值值.split(',').map(项目21 => 项目21.trim()).filter(项目20 => 项目20);
const 结果 = [];
for (const 项目19 of 项目列表) {
let 节点名称 = '';
let 地址部分 = 项目19;
if (项目19.includes('#')) {
const 部分列表 = 项目19.split('#');
地址部分 = 部分列表[0].trim();
节点名称 = 部分列表[1].trim();
}
const {
address: 地址,
port: 端口18
} = 解析地址值端口(地址部分);
if (!节点名称) {
节点名称 = 地址 + (端口18 ? ':' + 端口18 : '');
}
结果.push({
ip: 地址,
port: 端口18 || 443,
name: 节点名称,
addedAt: new Date().toISOString()
});
}
return 结果;
}
function 处理数组值值(数组) {
if (!数组 || 数组.length === 0) return '';
return 数组.map(项目 => {
const 端口17 = 项目.port || 443;
return `${项目.ip}:${端口17}#${项目.name}`;
}).join(',');
}
function 是否有效域名(域名) {
const 域名正则 = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
return 域名正则.test(域名);
}
async function 解析文本值数组(内容) {
var 已处理 = 内容.replace(/[ "'\r\n]+/g, ',').replace(/,+/g, ',');
if (已处理.charAt(0) == ',') 已处理 = 已处理.slice(1);
if (已处理.charAt(已处理.length - 1) == ',') 已处理 = 已处理.slice(0, 已处理.length - 1);
return 已处理.split(',');
}
async function 获取优选接口(网址列表, 默认端口 = '443', 超时 = 3000) {
if (!网址列表?.length) return [];
const 结果列表 = new Set();
await Promise.allSettled(网址列表.map(async 网址 => {
try {
const 控制器 = new AbortController();
const 超时标识 = setTimeout(() => 控制器.abort(), 超时);
const 响应 = await fetch(网址, {
signal: 控制器.signal
});
clearTimeout(超时标识);
let 文本 = '';
try {
const 缓冲 = await 响应.arrayBuffer();
const 内容类型 = (响应.headers.get('content-type') || '').toLowerCase();
const 字符集 = 内容类型.match(/charset=([^\s;]+)/i)?.[1]?.toLowerCase() || '';
let 解码器列表 = ['utf-8', 'gb2312'];
if (字符集.includes('gb') || 字符集.includes('gbk') || 字符集.includes('gb2312')) {
解码器列表 = ['gb2312', 'utf-8'];
}
let 解码成功 = false;
for (const 解码器 of 解码器列表) {
try {
const 已解码 = new TextDecoder(解码器).decode(缓冲);
if (已解码 && 已解码.length > 0 && !已解码.includes('\ufffd')) {
文本 = 已解码;
解码成功 = true;
break;
} else if (已解码 && 已解码.length > 0) {
continue;
}
} catch (事件值16) {
continue;
}
}
if (!解码成功) {
文本 = await 响应.text();
}
if (!文本 || 文本.trim().length === 0) {
return;
}
} catch (事件值15) {
return;
}
const 行列表 = 文本.trim().split('\n').map(行值14 => 行值14.trim()).filter(行值 => 行值);
const 是否值 = 行列表.length > 1 && 行列表[0].includes(',');
const 六版地址模式 = /^[^\[\]]*:[^\[\]]*:[^\[\]]/;
if (!是否值) {
行列表.forEach(行13 => {
const 井号索引 = 行13.indexOf('#');
const [主机部分, 备注] = 井号索引 > -1 ? [行13.substring(0, 井号索引), 行13.substring(井号索引)] : [行13, ''];
let 是否有端口 = false;
if (主机部分.startsWith('[')) {
是否有端口 = /\]:(\d+)$/.test(主机部分);
} else {
const 值索引 = 主机部分.lastIndexOf(':');
是否有端口 = 值索引 > -1 && /^\d+$/.test(主机部分.substring(值索引 + 1));
}
const 端口12 = new URL(网址).searchParams.get('port') || 默认端口;
结果列表.add(是否有端口 ? 行13 : `${主机部分}:${端口12}${备注}`);
});
} else {
const 头部列表 = 行列表[0].split(',').map(头值11 => 头值11.trim());
const 数据行列表 = 行列表.slice(1);
if (头部列表.includes('IP地址') && 头部列表.includes('端口') && 头部列表.includes('数据中心')) {
const 地址索引10 = 头部列表.indexOf('IP地址'),
端口索引 = 头部列表.indexOf('端口');
const 备注索引 = 头部列表.indexOf('国家') > -1 ? 头部列表.indexOf('国家') : 头部列表.indexOf('城市') > -1 ? 头部列表.indexOf('城市') : 头部列表.indexOf('数据中心');
const 传输层安全索引 = 头部列表.indexOf('TLS');
数据行列表.forEach(行9 => {
const 列列表8 = 行9.split(',').map(丙值7 => 丙值7.trim());
if (传输层安全索引 !== -1 && 列列表8[传输层安全索引]?.toLowerCase() !== 'true') return;
const 包裹地址6 = 六版地址模式.test(列列表8[地址索引10]) ? `[${列列表8[地址索引10]}]` : 列列表8[地址索引10];
结果列表.add(`${包裹地址6}:${列列表8[端口索引]}#${列列表8[备注索引]}`);
});
} else if (头部列表.some(头值5 => 头值5.includes('IP')) && 头部列表.some(头值4 => 头值4.includes('延迟')) && 头部列表.some(头值3 => 头值3.includes('下载速度'))) {
const 地址索引 = 头部列表.findIndex(头值2 => 头值2.includes('IP'));
const 延迟索引 = 头部列表.findIndex(头值1 => 头值1.includes('延迟'));
const 速度索引 = 头部列表.findIndex(头值 => 头值.includes('下载速度'));
const 端口 = new URL(网址).searchParams.get('port') || 默认端口;
数据行列表.forEach(行 => {
const 列列表 = 行.split(',').map(丙值 => 丙值.trim());
const 包裹地址 = 六版地址模式.test(列列表[地址索引]) ? `[${列列表[地址索引]}]` : 列列表[地址索引];
结果列表.add(`${包裹地址}:${端口}#CF优选 ${列列表[延迟索引]}ms ${列列表[速度索引]}MB/s`);
});
}
}
} catch (事件值) {}
}));
return Array.from(结果列表);
}
|