clash全局脚本

// ==================== 用户配置区域 ====================
/**
 * Clash配置生成器 - 简化版
 * 
 * 配置说明:
 * 1. rules - 字符串格式:
 *	- 不指定: 使用默认规则 (name.yaml)
 *	- 以.yaml结尾: 自定义路径 (如: "GitHub/GitHub.yaml")
 *	- 其他字符串: 规则变体 (如: "Classical")
 * 
 * 2. proxy - 字符串格式:
 *	- "DIRECT": 直连
 *	- "REJECT": 拒绝连接
 *	- 区域节点名称: 使用特定区域节点 (如: "香港节点")
 *	- 其他字符串: 使用指定的代理组
 * 
 * 3. icon - 图标配置:
 *	- 字符串名称: 使用预定义图标 (如: "GitHub")
 *	- URL: 使用自定义图标
 */

/**
 * @typedef {Object} RuleProvider
 * @property {string} name - 规则名称
 * @property {string} [icon] - 分组图标
 * @property {string} [proxy] - 代理设置，支持 "DIRECT"、"REJECT" 或分组名称
 * @property {string} [rules] - 规则配置，支持以下格式:
 *   - 不指定: 使用默认规则 (name.yaml)
 *   - 以 .yaml 结尾: 视为自定义路径
 *   - 其他字符串: 视为规则变体名称 (name_variant.yaml)
 */

/**
 * @typedef {Object} ProxyGroupOptions
 * @property {number} [interval] - 测速间隔(秒)
 * @property {number} [timeout] - 连接超时(毫秒)
 * @property {string} [url] - 测速URL
 * @property {boolean} [lazy] - 是否懒加载
 */

/**
 * @typedef {Object} UserConfig
 * @property {string[]} [customRules] - 自定义规则，优先级最高
 * @property {string} [excludeRegex] - 需要排除的节点名称正则
 * @property {RuleProvider[]} [ruleProviders] - 规则提供者配置
 * @property {ProxyGroupOptions} [proxyGroupOptions] - 代理组通用配置
 * @property {string} [iconCDN] - 图标CDN配置
 * @property {Object} [dns] - DNS配置
 */

/**
 * 用户配置对象
 * @type {UserConfig}
 */
const userConfig = {
	// 自定义规则 - 优先级最高
	customRules: [
		"IP-CIDR, 11.48.0.0/16,DIRECT,no-resolve",
		"IP-CIDR, 10.57.0.0/16,DIRECT,no-resolve",
		"IP-CIDR, 100.192.3.185/24,DIRECT,no-resolve",
		...createWhiteDomainList([
			"clivia.fun",
			"baidu.com",
			"360.net",
			"hf.space",
			"linux.do",
			"pages.dev",
			"nbcharts.com",
			"workers.dev",
			'deno.dev'
		])
	],

	/**
	 * 规则提供者配置
	 * 规则名称参考： https://github.com/blackmatrix7/ios_rule_script/tree/master/rule/Clash#分类
	 * 图标获取参考： https://www.clashverge.dev/guide/group_icon/icon_sets/Qure.html
	 * 
	 * @type {RuleProvider[]}
	 */
	ruleProviders: [
		// 使用规则变体
		{ name: 'ChinaMax', icon: 'China', rules: 'Classical', proxy: 'DIRECT' },
		
		// 默认规则
		{ name: 'Google' },
		
		// 使用自定义图标和特定区域节点
		{ name: 'Gemini', icon: 'https://registry.npmmirror.com/@lobehub/icons-static-png/latest/files/light/gemini-color.png', proxy: '非港澳节点' },
		
		{ name: 'YouTube' },
		{ name: 'Telegram' },
		
		// 直连规则
		{ name: 'Microsoft', icon: 'Microsoft', proxy: 'DIRECT' },
		
		// 使用自定义路径
		{ name: 'GitHub', rules: 'GitHub/GitHub.yaml' },
		
		{ name: 'Cloudflare', proxy: 'DIRECT' },
		{ name: '360', icon: 'Ninja', proxy: 'DIRECT' },
	]
};

// ==================== 常量定义 ====================
const CONSTANTS = {
	// 区域正则定义
	REGION_REGEX: {
		HONG_KONG: {
			name: "香港节点",
			regex: /港|HK|hk|Hong Kong|HongKong|hongkong|Hongkong|🇭🇰/u,
			icon: "Hong_Kong"
		},
		TAIWAN: {
			name: "台湾节点",
			regex: /台|新北|彰化|TW|Taiwan/u,
			icon: "TW"
		},
		US: {
			name: "美国节点",
			regex: /美|波特兰|达拉斯|俄勒冈|凤凰城|费利蒙|硅谷|拉斯维加斯|洛杉矶|圣何塞|圣克拉拉|西雅图|芝加哥|US|United States/u,
			icon: "United_States"
		},
		JAPAN: {
			name: "日本节点",
			regex: /日本|川日|东京|大阪|泉日|埼玉|沪日|深日|JP|Japan|Tokyo/u,
			icon: "Japan"
		},
		SINGAPORE: {
			name: "狮城节点",
			regex: /新加坡|坡|狮城|SG|Singapore/u,
			icon: "Singapore"
		},
		NON_HK_MO: {
			name: "非港澳节点",
			regex: /^(?!.*(?:🇭🇰|🇲🇴|港|澳|hk|mo|hong kong|macau)).*/ui,
			icon: "Area"
		}
	},

	// 常用代理组名称
	PROXY_GROUPS: {
		AUTO_SELECT: "自动选择",
		GLOBAL_DIRECT: "全球直连",
		AD_BLOCK: "广告拦截",
		FINAL: "漏网之鱼"
	},

	// 规则提供者基础URL
	RULE_PROVIDER_BASE_URL: "https://cdn.jsdelivr.net/gh/blackmatrix7/ios_rule_script@master/rule/Clash"
};

// ==================== 默认配置 ====================
const defaultConfig = {
	// 自定义规则 - 优先级最高
	customRules: [],

	// 需要排除的节点名称正则
	excludeRegex: "(?!.*(官网|网站|流量|套餐|到期|剩余|更新|产品|官方|客服|联系|邮箱|工单|群|频道|公告|推荐|返利|充值|付费|提示|警告|维护|测试|过期|失效)).*",

	// 规则提供者配置
	ruleProviders: [],

	// 代理组通用配置
	proxyGroupOptions: {
		interval: 300,
		timeout: 3000,
		url: "https://www.google.com/generate_204",
		// lazy: true
	},

	// 图标CDN配置
	iconCDN: "https://fastly.jsdelivr.net/gh/Koolson/Qure@master/IconSet/Color",

	// DNS配置
	dns: {
		"enable": true,
		"listen": "0.0.0.0:1053",
		"ipv6": true,
		"use-system-hosts": false,
		"cache-algorithm": "arc",
		"enhanced-mode": "fake-ip",
		"fake-ip-range": "198.18.0.1/16",
		"fake-ip-filter": [
			"+.lan",
			"+.local",
			"+.msftconnecttest.com",
			"+.msftncsi.com",
			"localhost.ptlogin2.qq.com",
			"localhost.sec.qq.com",
			"localhost.work.weixin.qq.com"
		],
		"default-nameserver": [
			"223.5.5.5",
			"119.29.29.29",
			"1.1.1.1",
			"8.8.8.8"
		],
		"nameserver": [
			"https://dns.alidns.com/dns-query",
			"https://doh.pub/dns-query",
			"https://doh.360.cn/dns-query",
			"https://1.1.1.1/dns-query",
			"https://1.0.0.1/dns-query",
			"https://208.67.222.222/dns-query",
			"https://208.67.220.220/dns-query",
			"https://194.242.2.2/dns-query",
			"https://194.242.2.3/dns-query"
		],
		"proxy-server-nameserver": [
			"https://dns.alidns.com/dns-query",
			"https://doh.pub/dns-query",
			"https://doh.360.cn/dns-query",
			"https://1.1.1.1/dns-query",
			"https://1.0.0.1/dns-query",
			"https://208.67.222.222/dns-query",
			"https://208.67.220.220/dns-query",
			"https://194.242.2.2/dns-query",
			"https://194.242.2.3/dns-query"
		],
		"nameserver-policy": {
			"geosite:private,cn,geolocation-cn": [
				"https://dns.alidns.com/dns-query",
				"https://doh.pub/dns-query",
				"https://doh.360.cn/dns-query"
			],
			"geosite:google,youtube,telegram,gfw,geolocation-!cn": [
				"https://1.1.1.1/dns-query",
				"https://1.0.0.1/dns-query",
				"https://208.67.222.222/dns-query",
				"https://208.67.220.220/dns-query",
				"https://194.242.2.2/dns-query",
				"https://194.242.2.3/dns-query"
			]
		}
	}
};

// ==================== 工具函数 ====================
/**
 * 创建白名单域名列表
 * @param {string[]} domainList - 域名列表
 * @returns {string[]} - 白名单域名列表
 */
function createWhiteDomainList(domainList) {
	return domainList.map(domain => `DOMAIN-SUFFIX,${domain},DIRECT`);
}

/**
 * 工具函数集合
 */
const utils = {
	/**
	 * 将任何值标准化为数组
	 * @param {*} value - 输入值
	 * @return {Array} 标准化后的数组
	 */
	toArray(value) {
		return value ? (Array.isArray(value) ? value : [value]) : [];
	},

	/**
	 * 获取代理动作
	 * @param {string} proxy - 代理设置
	 * @param {string} groupName - 分组名称
	 * @return {string} - 处理后的代理配置
	 */
	getProxyAction(proxy, groupName) {
		// 如果未指定代理，使用组名
		if (proxy === undefined || proxy === null) {
			return groupName;
		}

		// 只处理字符串类型
		if (typeof proxy === 'string') {
			const proxyValue = proxy.trim();
			// 如果是空字符串，返回DIRECT
			if (proxyValue === '') {
				return 'DIRECT';
			}
			return proxyValue;
		}

		// 默认返回组名
		return groupName;
	},

	/**
	 * 判断是否为URL
	 * @param {string} url - 待检测的字符串
	 * @returns {boolean} 是否为URL
	 */
	isUrl(url) {
		if (typeof url !== 'string') return false;
		return /^https?:\/\//i.test(url);
	},

	/**
	 * 判断是否为对象
	 * @param {*} item - 待检测的项
	 * @returns {boolean} 是否为对象
	 */
	isObject(item) {
		return (item && typeof item === 'object' && !Array.isArray(item));
	},

	/**
	 * 合并对象，深度合并
	 * @param {Object} target - 目标对象
	 * @param {Object} source - 源对象
	 * @returns {Object} 合并后的对象
	 */
	mergeObjects(target, source) {
		if (!source) return target;
		if (!this.isObject(source)) return source;

		if (!this.isObject(target)) {
			return JSON.parse(JSON.stringify(source));
		}

		const merged = Object.assign({}, target);

		Object.keys(source).forEach(key => {
			const sourceValue = source[key];

			if (this.isObject(sourceValue) && !Array.isArray(sourceValue)) {
				if (!target[key] || !this.isObject(target[key])) {
					merged[key] = JSON.parse(JSON.stringify(sourceValue));
				} else {
					merged[key] = this.mergeObjects(target[key], sourceValue);
				}
			}
			else if (Array.isArray(sourceValue)) {
				merged[key] = JSON.parse(JSON.stringify(sourceValue));
			}
			else {
				merged[key] = sourceValue;
			}
		});

		return merged;
	},

	/**
	 * 编译正则表达式
	 * @param {string|RegExp} pattern - 正则表达式或模式字符串
	 * @param {string} [flags] - 正则表达式标志
	 * @returns {RegExp} 编译后的正则表达式
	 */
	compileRegex(pattern, flags) {
		if (pattern instanceof RegExp) {
			return pattern;
		}

		if (typeof pattern !== 'string') {
			return new RegExp('.*');
		}

		try {
			return new RegExp(pattern, flags);
		} catch (e) {
			return new RegExp('.*');
		}
	}
};

/**
 * 图标管理类
 */
class IconManager {
	/**
	 * 创建图标管理器
	 * @param {UserConfig} config - 用户配置
	 */
	constructor(config) {
		this.config = config || {};
		this.iconCache = new Map();
		this.defaultIcon = `${this.config.iconCDN || defaultConfig.iconCDN}/Global.png`;
	}

	/**
	 * 获取图标URL
	 * @param {string} iconName - 图标名称
	 * @returns {string} 图标URL
	 */
	getIcon(iconName) {
		if (iconName === null || iconName === undefined) {
			return this.defaultIcon;
		}

		const cacheKey = String(iconName);
		if (this.iconCache.has(cacheKey)) {
			return this.iconCache.get(cacheKey);
		}

		let iconUrl;
		if (utils.isUrl(iconName)) {
			iconUrl = iconName;
		} else if (!iconName) {
			iconUrl = this.defaultIcon;
		} else {
			const iconCDN = this.config.iconCDN || defaultConfig.iconCDN;
			iconUrl = `${iconCDN}/${iconName}.png`;
		}

		this.iconCache.set(cacheKey, iconUrl);

		return iconUrl;
	}

	/**
	 * 预加载常用图标到缓存
	 */
	preloadCommonIcons() {
		const commonIcons = ['Direct', 'AdBlack', 'Final', 'Global', 'Auto'];
		commonIcons.forEach(name => {
			this.getIcon(name);
		});

		Object.values(CONSTANTS.REGION_REGEX).forEach(region => {
			this.getIcon(region.icon);
		});
	}
}

/**
 * 规则管理类
 */
class RuleManager {
	/**
	 * 创建规则管理器
	 * @param {UserConfig} config - 用户配置
	 * @param {IconManager} iconManager - 图标管理器
	 */
	constructor(config, iconManager) {
		this.config = config || {};
		this.iconManager = iconManager;
	}

	/**
	 * 获取规则文件URL
	 * @param {string} name - 规则名称
	 * @param {string} rules - 规则配置
	 * @returns {string} 规则文件URL
	 * @private
	 */
	_getRuleUrl(name, rules) {
		const baseUrl = CONSTANTS.RULE_PROVIDER_BASE_URL;

		// 如果未提供rules，使用默认规则
		if (!rules) {
			return `${baseUrl}/${name}/${name}.yaml`;
		}

		// 如果rules以.yaml结尾，视为自定义路径
		if (typeof rules === 'string' && rules.endsWith('.yaml')) {
			return `${baseUrl}/${rules}`;
		}

		// 其他字符串视为变体名称
		if (typeof rules === 'string') {
			return `${baseUrl}/${name}/${name}_${rules}.yaml`;
		}

		// 默认返回
		return `${baseUrl}/${name}/${name}.yaml`;
	}

	/**
	 * 获取规则文件本地路径
	 * @param {string} name - 规则名称
	 * @param {string} rules - 规则配置
	 * @returns {string} 本地路径
	 * @private
	 */
	_getLocalPath(name, rules) {
		// 如果未提供rules，使用默认规则
		if (!rules) {
			return `./ruleset/tnnevol/${name}.yaml`;
		}

		// 如果rules以.yaml结尾，提取文件名部分
		if (typeof rules === 'string' && rules.endsWith('.yaml')) {
			const parts = rules.split('/');
			return `./ruleset/tnnevol/${parts[parts.length - 1]}`;
		}

		// 其他字符串视为变体名称
		if (typeof rules === 'string') {
			return `./ruleset/tnnevol/${name}_${rules}.yaml`;
		}

		// 默认返回
		return `./ruleset/tnnevol/${name}.yaml`;
	}

	/**
	 * 创建规则提供者配置
	 * @returns {Object} 规则提供者配置对象
	 */
	createRuleProviders() {
		const providers = {};
		const ruleProviders = this.config.ruleProviders || [];

		ruleProviders.forEach(({ name, icon, rules }) => {
			if (!name) return;

			providers[name] = {
				type: "http",
				format: "yaml",
				interval: 86400,
				behavior: "classical",
				url: this._getRuleUrl(name, rules),
				icon: this.iconManager.getIcon(icon || name),
				path: this._getLocalPath(name, rules)
			};
		});

		return providers;
	}

	/**
	 * 创建规则列表
	 * @returns {string[]} 规则列表
	 */
	createRules() {
		const ruleProviders = this.config.ruleProviders || [];
		const rules = [];

		for (let i = 0; i < ruleProviders.length; i++) {
			const item = ruleProviders[i];
			if (!item || !item.name) continue;

			const action = utils.getProxyAction(item.proxy, item.name);
			rules.push(`RULE-SET,${item.name},${action}`);
		}

		return rules;
	}

	/**
	 * 生成完整规则列表
	 * @returns {string[]} 完整规则列表
	 */
	generateRules() {
		const pgNames = CONSTANTS.PROXY_GROUPS;
		const customRules = this.config.customRules || [];
		const ruleProviderRules = this.createRules();

		const rules = [
			...customRules,
			...ruleProviderRules,
			`GEOSITE,cn,${pgNames.GLOBAL_DIRECT},DIRECT`,
			`GEOSITE,google-cn,${pgNames.GLOBAL_DIRECT},DIRECT`,
			`GEOSITE,category-games@cn,${pgNames.GLOBAL_DIRECT},DIRECT`,
			`GEOSITE,category-public-tracker,${pgNames.GLOBAL_DIRECT},DIRECT`,
			`GEOSITE,gfw,${pgNames.AUTO_SELECT},PROXY`,
			`GEOIP,LAN,${pgNames.GLOBAL_DIRECT},no-resolve`,
			`GEOIP,CN,${pgNames.GLOBAL_DIRECT},no-resolve`,
			`MATCH,${pgNames.FINAL}`
		];

		return rules;
	}
}

/**
 * 代理组管理类
 */
class ProxyGroupManager {
	/**
	 * 创建代理组管理器
	 * @param {UserConfig} config - 用户配置
	 * @param {IconManager} iconManager - 图标管理器
	 */
	constructor(config, iconManager) {
		this.config = config || {};
		this.iconManager = iconManager;
		this.excludeRegex = utils.compileRegex(this.config.excludeRegex || "", "u");
		this._regionDefinitions = Object.values(CONSTANTS.REGION_REGEX);
	}

	/**
	 * 获取符合正则表达式的代理列表
	 * @param {Array} proxies - 代理列表
	 * @param {string|RegExp} regexStr - 正则表达式或模式
	 * @param {Array} [concatProxies=[]] - 要合并的额外代理
	 * @returns {Array} 筛选后的代理列表
	 */
	getProxiesByRegex(proxies, regexStr, concatProxies = []) {
		if (!proxies || !Array.isArray(proxies)) {
			return [...concatProxies];
		}

		const regex = utils.compileRegex(regexStr, "u");
		const filteredProxies = [];

		for (let i = 0; i < proxies.length; i++) {
			const proxy = proxies[i];
			if (proxy && proxy.name &&
				regex.test(proxy.name) &&
				this.excludeRegex.test(proxy.name)) {
				filteredProxies.push(proxy.name);
			}
		}

		if (concatProxies.length > 0) {
			filteredProxies.push(...concatProxies);
		}

		return filteredProxies;
	}

	/**
	 * 创建区域分组
	 * @param {Array} proxies - 代理列表
	 * @returns {Array} 区域分组列表
	 */
	createRegionGroups(proxies) {
		if (!proxies || !Array.isArray(proxies)) {
			proxies = [];
		}

		const regionGroups = [];

		for (let i = 0; i < this._regionDefinitions.length; i++) {
			const region = this._regionDefinitions[i];

			const regionProxies = this.getProxiesByRegex(
				proxies,
				region.regex
			);

			if (regionProxies.length === 0) continue;

			regionGroups.push({
				...this.config.proxyGroupOptions,
				name: region.name,
				type: "url-test",
				tolerance: 30,
				proxies: regionProxies,
				icon: this.iconManager.getIcon(region.icon)
			});
		}

		return regionGroups;
	}

	/**
	 * 创建基础代理组
	 * @param {Array} regionGroups - 区域分组
	 * @returns {Array} 代理组列表
	 */
	createBaseProxyGroups(regionGroups) {
		if (!regionGroups) {
			regionGroups = [];
		}

		const pgNames = CONSTANTS.PROXY_GROUPS;
		const regionGroupNames = regionGroups.map(group => group.name);

		// 简化的公共代理列表，只包含自动选择和区域组
		const commonProxies = [
			pgNames.AUTO_SELECT,
			...regionGroupNames,
			"DIRECT",
		];

		// 简化的基础分组，只保留自动选择
		const baseGroups = [
			{
				...this.config.proxyGroupOptions,
				name: pgNames.AUTO_SELECT,
				type: "url-test",
				tolerance: 100,
				filter: this.config.excludeRegex,
				"include-all": true,
				icon: this.iconManager.getIcon("Auto")
			}
		];

		const ruleProviders = this.config.ruleProviders || [];
		const ruleGroups = [];

		for (let i = 0; i < ruleProviders.length; i++) {
			const item = ruleProviders[i];
			if (!item || !item.name) continue;

			// 根据proxy设置决定代理列表
			let proxyList;
			
			if (item.proxy === "DIRECT") {
				proxyList = ["DIRECT"];
			} else if (item.proxy === "REJECT") {
				proxyList = ["REJECT"];
			} else if (typeof item.proxy === 'string' && item.proxy.trim() !== '') {
				const proxyName = item.proxy.trim();
				// 检查是否是已存在于commonProxies中的代理组名称
				if (commonProxies.includes(proxyName)) {
					// 如果是，使用过滤后的代理列表（将指定的代理放在首位）
					proxyList = [proxyName, ...commonProxies.filter(p => p !== proxyName)];
				} else {
					// 如果不是，将其添加到列表首位
					proxyList = [proxyName, ...commonProxies];
				}
			} else {
				// 默认使用所有代理
				proxyList = commonProxies;
			}

			ruleGroups.push({
				...this.config.proxyGroupOptions,
				name: item.name,
				type: "select",
				proxies: proxyList,
				icon: this.iconManager.getIcon(item.icon || item.name)
			});
		}

		// 简化特殊分组
		const specialGroups = [
			{
				...this.config.proxyGroupOptions,
				name: pgNames.GLOBAL_DIRECT,
				type: "select",
				proxies: ["DIRECT", pgNames.AUTO_SELECT],
				icon: this.iconManager.getIcon("Direct")
			},
			{
				...this.config.proxyGroupOptions,
				name: pgNames.AD_BLOCK,
				type: "select",
				proxies: ["REJECT", "DIRECT"],
				icon: this.iconManager.getIcon("AdBlack")
			},
			{
				...this.config.proxyGroupOptions,
				name: pgNames.FINAL,
				type: "select",
				proxies: commonProxies,
				icon: this.iconManager.getIcon("Final")
			}
		];

		return [
			...baseGroups,
			...ruleGroups,
			...specialGroups,
			...regionGroups
		];
	}
}

/**
 * Clash配置生成器类
 */
class ClashConfigGenerator {
	/**
	 * 创建Clash配置生成器
	 * @param {UserConfig} userConfig - 用户配置
	 */
	constructor(userConfig = {}) {
		this.config = utils.mergeObjects(defaultConfig, userConfig);
		this.iconManager = new IconManager(this.config);
		this.ruleManager = new RuleManager(this.config, this.iconManager);
		this.proxyGroupManager = new ProxyGroupManager(this.config, this.iconManager);
		this.iconManager.preloadCommonIcons();
	}

	/**
	 * 生成Clash配置
	 * @param {Object} clashConfig - 原始Clash配置
	 * @returns {Object} 处理后的Clash配置
	 */
	generate(clashConfig) {
		try {
			if (!clashConfig) {
				clashConfig = {};
			}

			const proxies = Array.isArray(clashConfig.proxies) ? clashConfig.proxies : [];
			const regionGroups = this.proxyGroupManager.createRegionGroups(proxies);
			const allProxyGroups = this.proxyGroupManager.createBaseProxyGroups(regionGroups);
			const ruleProviders = this.ruleManager.createRuleProviders();
			const rules = this.ruleManager.generateRules();

			return Object.assign({}, clashConfig, {
				dns: this.config.dns,
				"rule-providers": ruleProviders,
				rules: rules,
				"proxy-groups": allProxyGroups
			});
		} catch (error) {
			return clashConfig || {};
		}
	}
}

/**
 * 主函数 - 处理配置
 * @param {Object} config - 原始配置
 * @returns {Object} 处理后的配置
 */
function main(config) {
	try {
		if (!main.generator) {
			main.generator = new ClashConfigGenerator(userConfig);
		}

		return main.generator.generate(config);
	} catch (error) {
		return config || {};
	}
}