@subconverter/core 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -25,6 +25,8 @@ __export(index_exports, {
   ProxyGroupType: () => ProxyGroupType,
   ProxyType: () => ProxyType,
   QUANX_RULE_TYPES: () => QUANX_RULE_TYPES,
+  REGEX_BLACKLIST: () => REGEX_BLACKLIST,
+  RULESET_TYPE_PREFIXES: () => RULESET_TYPE_PREFIXES,
   RulesetType: () => RulesetType,
   SING_BOX_RULE_TYPES: () => SING_BOX_RULE_TYPES,
   SSR_CIPHERS: () => SSR_CIPHERS,
@@ -56,12 +58,14 @@ __export(index_exports, {
   explodeClash: () => explodeClash,
   explodeHttp: () => explodeHttp,
   explodeHttpSub: () => explodeHttpSub,
+  explodeHysteria: () => explodeHysteria,
   explodeHysteria2: () => explodeHysteria2,
   explodeKitsunebi: () => explodeKitsunebi,
   explodeNetch: () => explodeNetch,
   explodeNetchConf: () => explodeNetchConf,
   explodeQuan: () => explodeQuan,
   explodeShadowrocket: () => explodeShadowrocket,
+  explodeSnell: () => explodeSnell,
   explodeSocks: () => explodeSocks,
   explodeSs: () => explodeSs,
   explodeSsAndroid: () => explodeSsAndroid,
@@ -78,7 +82,9 @@ __export(index_exports, {
   explodeVless: () => explodeVless,
   explodeVmess: () => explodeVmess,
   explodeVmessConf: () => explodeVmessConf,
+  explodeWireguard: () => explodeWireguard,
   filterNodes: () => filterNodes,
+  filterNodesByCountry: () => filterNodesByCountry,
   findSection: () => findSection,
   fnv1a64: () => fnv1a64,
   fnv1a64Hex: () => fnv1a64Hex,
@@ -100,6 +106,7 @@ __export(index_exports, {
   hysteria2Construct: () => hysteria2Construct,
   hysteriaConstruct: () => hysteriaConstruct,
   inferUserinfoProviderFromUrl: () => inferUserinfoProviderFromUrl,
+  isBlacklistedPattern: () => isBlacklistedPattern,
   isBlank: () => isBlank,
   isFlattenableSsr: () => isFlattenableSsr,
   isIp: () => isIp,
@@ -113,9 +120,11 @@ __export(index_exports, {
   nodeNameRegex: () => nodeNameRegex,
   nodeNameRemove: () => nodeNameRemove,
   nodeRename: () => nodeRename,
+  normalizeCountryCode: () => normalizeCountryCode,
   normalizeQueryKey: () => normalizeQueryKey,
   normalizeUserinfoProvider: () => normalizeUserinfoProvider,
   pad2: () => pad2,
+  parseClashFlavor: () => parseClashFlavor,
   parseClashText: () => parseClashText,
   parseConfContent: () => parseConfContent,
   parseCustomProxyGroup: () => parseCustomProxyGroup,
@@ -130,6 +139,7 @@ __export(index_exports, {
   parseRegexMatch: () => parseRegexMatch,
   parseRequestSettings: () => parseRequestSettings,
   parseRulesetConfig: () => parseRulesetConfig,
+  parseRulesetSource: () => parseRulesetSource,
   parseSubscription: () => parseSubscription,
   parseSubscriptionUserinfo: () => parseSubscriptionUserinfo,
   parseTriBool: () => parseTriBool,
@@ -142,8 +152,6 @@ __export(index_exports, {
   queryBoolFlag: () => queryBoolFlag,
   regMatch: () => regMatch,
   regReplace: () => regReplace,
-  regionDisplayName: () => regionDisplayName,
-  regionFlag: () => regionFlag,
   removeEmoji: () => removeEmoji,
   renderRawIni: () => renderRawIni,
   renderTemplate: () => renderTemplate,
@@ -420,6 +428,16 @@ function createRulesetConfig() {
 }
 
 // src/types/settings.ts
+function parseClashFlavor(value) {
+  const normalized = (value ?? "").trim().toLowerCase();
+  if (normalized === "premium" || normalized === "original" || normalized === "classic" || normalized === "clash") {
+    return "premium";
+  }
+  if (normalized === "stash") {
+    return "stash";
+  }
+  return "mihomo";
+}
 var TargetFormat = /* @__PURE__ */ ((TargetFormat2) => {
   TargetFormat2["Clash"] = "clash";
   TargetFormat2["ClashR"] = "clashr";
@@ -448,16 +466,21 @@ function createExtraSettings() {
     authorized: false,
     autoCountry: false,
     clashClassicalRuleset: false,
+    clashFlavor: "mihomo",
     clashNewFieldName: true,
     clashProxiesStyle: "flow",
     clashProxyGroupsStyle: "flow",
     clashScript: false,
-    countryLocale: "zh-CN",
     countryResolver: void 0,
     dedupe: false,
     emojiArray: [],
     enableRuleGenerator: true,
+    excludeCountries: [],
+    excludeRemarks: [],
+    expandRulesets: true,
     filterDeprecated: false,
+    includeCountries: [],
+    includeRemarks: [],
     managedConfigPrefix: "",
     nameRegexArray: [],
     nameRemove: [],
@@ -470,6 +493,7 @@ function createExtraSettings() {
     sortFlag: false,
     sortScript: "",
     surgeSsrPath: "",
+    templateVars: {},
     tfo: void 0,
     tls13: void 0,
     udp: void 0
@@ -693,7 +717,7 @@ function toBool(value) {
     return false;
   }
   const normalized = value.trim().toLowerCase();
-  return normalized === "true" || normalized === "1";
+  return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
 }
 function strFind(haystack, needle) {
   return haystack.includes(needle);
@@ -842,6 +866,23 @@ function templateVariableNames(content) {
 }
 
 // src/settings/config.ts
+var RULESET_TYPE_PREFIXES = [
+  ["surge:", "surge" /* Surge */],
+  ["quanx:", "quanx" /* QuantumultX */],
+  ["quantumultx:", "quanx" /* QuantumultX */],
+  ["clash-domain:", "clash-domain" /* ClashDomain */],
+  ["clash-ipcidr:", "clash-ipcidr" /* ClashIpCidr */],
+  ["clash-classic:", "clash-classical" /* ClashClassical */],
+  ["clash:", "clash-classical" /* ClashClassical */]
+];
+function parseRulesetSource(source) {
+  for (const [prefix, type] of RULESET_TYPE_PREFIXES) {
+    if (source.toLowerCase().startsWith(prefix)) {
+      return { type, url: source.slice(prefix.length) };
+    }
+  }
+  return { url: source };
+}
 var GROUP_TYPE_MAP = {
   fallback: "fallback" /* Fallback */,
   "load-balance": "load-balance" /* LoadBalance */,
@@ -943,8 +984,10 @@ function parseExternalConfig(content) {
     baseFiles: {},
     emoji: [],
     enableRuleGenerator: true,
+    excludeCountries: [],
     excludeRemarks: [],
     groups: [],
+    includeCountries: [],
     includeRemarks: [],
     nameRegex: [],
     nameRemove: [],
@@ -1013,6 +1056,22 @@ function parseExternalConfig(content) {
             result.includeRemarks.push(value);
           }
           break;
+        case "include_country":
+          for (const fragment of value.split(",")) {
+            const trimmed = fragment.trim().toUpperCase();
+            if (trimmed !== "") {
+              result.includeCountries.push(trimmed);
+            }
+          }
+          break;
+        case "exclude_country":
+          for (const fragment of value.split(",")) {
+            const trimmed = fragment.trim().toUpperCase();
+            if (trimmed !== "") {
+              result.excludeCountries.push(trimmed);
+            }
+          }
+          break;
         case "exclude_remarks":
         case "exclude":
           if (value !== "") {
@@ -1067,6 +1126,9 @@ function listArg(query, key) {
   const value = getUrlArg(query, key);
   return value === "" ? [] : value.split(",");
 }
+function countryListArg(query, key) {
+  return getAllUrlArgs(query, key).flatMap((raw) => raw.split(",")).map((raw) => raw.trim().toUpperCase()).filter((raw) => raw !== "");
+}
 function resolveNewFieldName(query) {
   if (boolArg(query, "legacy") || boolArg(query, "legacy_field_name") || boolArg(query, "legacy-field-name")) {
     return false;
@@ -1105,13 +1167,19 @@ function createRequestSettings() {
     appendType: false,
     autoCountry: false,
     autoExtract: false,
+    clashFlavor: "mihomo",
     clashScript: false,
     classicalRuleset: false,
     dedupe: false,
+    devId: "",
     emoji: [],
+    excludeCountries: [],
     excludeRemarks: [],
+    expand: true,
+    filename: "",
     filterDeprecated: false,
     group: [],
+    includeCountries: [],
     includeRemarks: [],
     insert: false,
     interval: 0,
@@ -1129,6 +1197,7 @@ function createRequestSettings() {
     script: "",
     scv: void 0,
     sort: false,
+    strict: false,
     target: "auto" /* Auto */,
     tfo: void 0,
     tls13: void 0,
@@ -1157,6 +1226,11 @@ function parseRequestSettings(query) {
   settings.filterDeprecated = boolArg(query, "filter_deprecated");
   settings.newFieldName = resolveNewFieldName(query);
   settings.classicalRuleset = boolArg(query, "classical");
+  settings.clashFlavor = parseClashFlavor(firstArg(query, "flavor"));
+  settings.expand = queryBoolFlag(query, "expand") ?? true;
+  settings.strict = boolArg(query, "strict");
+  settings.filename = firstArg(query, "filename");
+  settings.devId = firstArg(query, "dev_id", "dev-id", "device_id", "device-id");
   settings.insert = getUrlArg(query, "insert") !== "";
   settings.clashScript = boolArg(query, "clash_script");
   settings.autoExtract = boolArg(query, "auto_extract");
@@ -1172,6 +1246,8 @@ function parseRequestSettings(query) {
   settings.proxyGroupsStyle = getUrlArg(query, "proxy_groups_style") || "flow";
   settings.includeRemarks = listArg(query, "include");
   settings.excludeRemarks = listArg(query, "exclude");
+  settings.includeCountries = countryListArg(query, "include_country");
+  settings.excludeCountries = countryListArg(query, "exclude_country");
   settings.userinfoUrl = firstArg(query, "userinfo_url", "userinfo-url", "userinfo");
   settings.userinfoProvider = firstArg(
     query,
@@ -2047,485 +2123,493 @@ function explodeClash(root, nodes) {
   }
   let index = nodes.length;
   for (const single of list) {
-    const proxyType = asString(get(single, "type")).toLowerCase();
-    const ps = asString(get(single, "name"));
-    const server = asString(get(single, "server"));
-    const port = asString(get(single, "port"));
-    let underlyingProxy = asString(get(single, "underlying-proxy"));
-    if (underlyingProxy === "") {
-      underlyingProxy = asString(get(single, "dialer-proxy"));
-    }
-    if (port === "" || port === "0") {
-      continue;
-    }
-    const udp = asTri(get(single, "udp"));
-    const tfo = asTri(get(single, "fast-open"));
-    const scv = asTri(get(single, "skip-cert-verify"));
-    const node = createProxy();
-    let group2 = "";
-    switch (proxyType) {
-      case "vmess": {
-        group2 = DEFAULT_GROUPS.v2ray;
-        const id = asString(get(single, "uuid"));
-        const aid = asString(get(single, "alterId"));
-        const cipher = asString(get(single, "cipher"));
-        const net = get(single, "network") !== void 0 ? asString(get(single, "network")) : "tcp";
-        const sni = asString(get(single, "servername"));
-        let path = "";
-        let host = "";
-        let edge = "";
-        switch (net) {
-          case "http":
-            path = asString(get(get(get(single, "http-opts"), "path"), 0));
-            host = asString(get(get(get(get(single, "http-opts"), "headers"), "Host"), 0));
-            edge = "";
-            break;
-          case "ws":
-            if (get(single, "ws-opts") !== void 0) {
-              const wsOpts = get(single, "ws-opts");
-              path = get(wsOpts, "path") !== void 0 ? asString(get(wsOpts, "path")) : "/";
-              host = asString(get(get(wsOpts, "headers"), "Host"));
-              edge = asString(get(get(wsOpts, "headers"), "Edge"));
-            } else {
-              path = get(single, "ws-path") !== void 0 ? asString(get(single, "ws-path")) : "/";
-              host = asString(get(get(single, "ws-headers"), "Host"));
-              edge = asString(get(get(single, "ws-headers"), "Edge"));
-            }
-            break;
-          case "h2":
-            path = asString(get(get(single, "h2-opts"), "path"));
-            host = asString(get(get(get(single, "h2-opts"), "host"), 0));
-            edge = "";
-            break;
-          case "grpc":
-            host = asString(get(single, "servername"));
-            path = asString(get(get(single, "grpc-opts"), "grpc-service-name"));
-            edge = "";
-            break;
-          default:
-            break;
-        }
-        const tls = asBool(get(single, "tls")) ? "tls" : "";
-        vmessConstruct(node, {
-          add: server,
-          aid,
-          cipher,
-          edge,
-          group: group2,
-          host,
-          id,
-          net,
-          path,
-          port,
-          remark: ps,
-          scv,
-          sni,
-          tfo,
-          tls,
-          type: "",
-          udp,
-          underlyingProxy
-        });
-        break;
+    try {
+      if (parseClashNode(single, nodes, index)) {
+        index += 1;
       }
-      case "ss": {
-        group2 = DEFAULT_GROUPS.ss;
-        let cipher = asString(get(single, "cipher"));
-        const password = asString(get(single, "password"));
-        let plugin = "";
-        let pluginOption = "";
-        let pluginMode = "";
-        let pluginHost = "";
-        let pluginMux = "";
-        let pluginTls = "";
-        let path = "";
-        if (get(single, "plugin") !== void 0) {
-          const pluginName = asString(get(single, "plugin")).toLowerCase();
-          const pluginOpts = get(single, "plugin-opts");
-          if (pluginName === "obfs") {
-            plugin = "obfs-local";
-            pluginMode = asString(get(pluginOpts, "mode"));
-            pluginHost = asString(get(pluginOpts, "host"));
-          } else if (pluginName === "v2ray-plugin") {
-            plugin = "v2ray-plugin";
-            pluginMode = asString(get(pluginOpts, "mode"));
-            pluginHost = asString(get(pluginOpts, "host"));
-            pluginTls = asBool(get(pluginOpts, "tls")) ? "tls;" : "";
-            path = asString(get(pluginOpts, "path"));
-            pluginMux = asBool(get(pluginOpts, "mux")) ? "mux=4;" : "";
-          }
-        } else if (get(single, "obfs") !== void 0) {
-          plugin = "obfs-local";
-          pluginMode = asString(get(single, "obfs"));
-          pluginHost = asString(get(single, "obfs-host"));
-        }
-        if (plugin === "simple-obfs" || plugin === "obfs-local") {
-          pluginOption = `obfs=${pluginMode}`;
-          pluginOption += pluginHost === "" ? "" : `;obfs-host=${pluginHost}`;
-        } else if (plugin === "v2ray-plugin") {
-          pluginOption = `mode=${pluginMode};${pluginTls}${pluginMux}`;
-          if (pluginHost !== "") {
-            pluginOption += `host=${pluginHost};`;
-          }
-          if (path !== "") {
-            pluginOption += `path=${path};`;
-          }
-          if (pluginMux !== "") {
-            pluginOption += `mux=${pluginMux};`;
+    } catch {
+    }
+  }
+}
+function parseClashNode(single, nodes, index) {
+  const proxyType = asString(get(single, "type")).toLowerCase();
+  const ps = asString(get(single, "name"));
+  const server = asString(get(single, "server"));
+  const port = asString(get(single, "port"));
+  let underlyingProxy = asString(get(single, "underlying-proxy"));
+  if (underlyingProxy === "") {
+    underlyingProxy = asString(get(single, "dialer-proxy"));
+  }
+  if (port === "" || port === "0") {
+    return false;
+  }
+  const udp = asTri(get(single, "udp"));
+  const tfo = asTri(get(single, "fast-open"));
+  const scv = asTri(get(single, "skip-cert-verify"));
+  const node = createProxy();
+  let group2 = "";
+  switch (proxyType) {
+    case "vmess": {
+      group2 = DEFAULT_GROUPS.v2ray;
+      const id = asString(get(single, "uuid"));
+      const aid = asString(get(single, "alterId"));
+      const cipher = asString(get(single, "cipher"));
+      const net = get(single, "network") !== void 0 ? asString(get(single, "network")) : "tcp";
+      const sni = asString(get(single, "servername"));
+      let path = "";
+      let host = "";
+      let edge = "";
+      switch (net) {
+        case "http":
+          path = asString(get(get(get(single, "http-opts"), "path"), 0));
+          host = asString(get(get(get(get(single, "http-opts"), "headers"), "Host"), 0));
+          edge = "";
+          break;
+        case "ws":
+          if (get(single, "ws-opts") !== void 0) {
+            const wsOpts = get(single, "ws-opts");
+            path = get(wsOpts, "path") !== void 0 ? asString(get(wsOpts, "path")) : "/";
+            host = asString(get(get(wsOpts, "headers"), "Host"));
+            edge = asString(get(get(wsOpts, "headers"), "Edge"));
+          } else {
+            path = get(single, "ws-path") !== void 0 ? asString(get(single, "ws-path")) : "/";
+            host = asString(get(get(single, "ws-headers"), "Host"));
+            edge = asString(get(get(single, "ws-headers"), "Edge"));
           }
-        }
-        if (cipher === "AEAD_CHACHA20_POLY1305") {
-          cipher = "chacha20-ietf-poly1305";
-        } else if (cipher.includes("AEAD")) {
-          cipher = cipher.replace(/AEAD_/g, "").replace(/_/g, "-").toLowerCase();
-        }
-        ssConstruct(node, {
-          group: group2,
-          method: cipher,
-          password,
-          plugin,
-          pluginOption,
-          port,
-          remark: ps,
-          scv,
-          server,
-          tfo,
-          udp,
-          underlyingProxy
-        });
-        break;
-      }
-      case "socks5": {
-        group2 = DEFAULT_GROUPS.socks;
-        const user = asString(get(single, "username"));
-        const password = asString(get(single, "password"));
-        socksConstruct(node, {
-          group: group2,
-          password,
-          port,
-          remark: ps,
-          server,
-          underlyingProxy,
-          username: user
-        });
-        break;
-      }
-      case "ssr": {
-        group2 = DEFAULT_GROUPS.ssr;
-        let cipher = asString(get(single, "cipher"));
-        if (cipher === "dummy") {
-          cipher = "none";
-        }
-        const password = asString(get(single, "password"));
-        const protocol = asString(get(single, "protocol"));
-        const obfs = asString(get(single, "obfs"));
-        const protocolParam = get(single, "protocol-param") !== void 0 ? asString(get(single, "protocol-param")) : asString(get(single, "protocolparam"));
-        const obfsParam = get(single, "obfs-param") !== void 0 ? asString(get(single, "obfs-param")) : asString(get(single, "obfsparam"));
-        ssrConstruct(node, {
-          group: group2,
-          method: cipher,
-          obfs,
-          obfsParam,
-          password,
-          port,
-          protocol,
-          protocolParam,
-          remark: ps,
-          scv,
-          server,
-          tfo,
-          udp,
-          underlyingProxy
-        });
-        break;
-      }
-      case "http": {
-        group2 = DEFAULT_GROUPS.http;
-        const user = asString(get(single, "username"));
-        const password = asString(get(single, "password"));
-        const tls = asString(get(single, "tls"));
-        httpConstruct(node, {
-          group: group2,
-          password,
-          port,
-          remark: ps,
-          scv,
-          server,
-          tfo,
-          tls: tls === "true",
-          underlyingProxy,
-          username: user
-        });
-        break;
+          break;
+        case "h2":
+          path = asString(get(get(single, "h2-opts"), "path"));
+          host = asString(get(get(get(single, "h2-opts"), "host"), 0));
+          edge = "";
+          break;
+        case "grpc":
+          host = asString(get(single, "servername"));
+          path = asString(get(get(single, "grpc-opts"), "grpc-service-name"));
+          edge = "";
+          break;
+        default:
+          break;
       }
-      case "trojan": {
-        group2 = DEFAULT_GROUPS.trojan;
-        const password = asString(get(single, "password"));
-        const host = asString(get(single, "sni"));
-        let net = asString(get(single, "network"));
-        let path = "";
-        switch (net) {
-          case "grpc":
-            path = asString(get(get(single, "grpc-opts"), "grpc-service-name"));
-            break;
-          case "ws":
-            path = asString(get(get(single, "ws-opts"), "path"));
-            break;
-          default:
-            net = "tcp";
-            path = "";
-            break;
+      const tls = asBool(get(single, "tls")) ? "tls" : "";
+      vmessConstruct(node, {
+        add: server,
+        aid,
+        cipher,
+        edge,
+        group: group2,
+        host,
+        id,
+        net,
+        path,
+        port,
+        remark: ps,
+        scv,
+        sni,
+        tfo,
+        tls,
+        type: "",
+        udp,
+        underlyingProxy
+      });
+      break;
+    }
+    case "ss": {
+      group2 = DEFAULT_GROUPS.ss;
+      let cipher = asString(get(single, "cipher"));
+      const password = asString(get(single, "password"));
+      let plugin = "";
+      let pluginOption = "";
+      let pluginMode = "";
+      let pluginHost = "";
+      let pluginMux = "";
+      let pluginTls = "";
+      let path = "";
+      if (get(single, "plugin") !== void 0) {
+        const pluginName = asString(get(single, "plugin")).toLowerCase();
+        const pluginOpts = get(single, "plugin-opts");
+        if (pluginName === "obfs") {
+          plugin = "obfs-local";
+          pluginMode = asString(get(pluginOpts, "mode"));
+          pluginHost = asString(get(pluginOpts, "host"));
+        } else if (pluginName === "v2ray-plugin") {
+          plugin = "v2ray-plugin";
+          pluginMode = asString(get(pluginOpts, "mode"));
+          pluginHost = asString(get(pluginOpts, "host"));
+          pluginTls = asBool(get(pluginOpts, "tls")) ? "tls;" : "";
+          path = asString(get(pluginOpts, "path"));
+          pluginMux = asBool(get(pluginOpts, "mux")) ? "mux=4;" : "";
         }
-        trojanConstruct(node, {
-          group: group2,
-          host,
-          network: net,
-          password,
-          path,
-          port,
-          remark: ps,
-          scv,
-          server,
-          tfo,
-          tlsSecure: true,
-          udp,
-          underlyingProxy
-        });
-        break;
-      }
-      case "snell": {
-        group2 = DEFAULT_GROUPS.snell;
-        const password = asString(get(single, "psk"));
-        const obfs = asString(get(get(single, "obfs-opts"), "mode"));
-        const host = asString(get(get(single, "obfs-opts"), "host"));
-        const version = asString(get(single, "version"));
-        snellConstruct(node, {
-          group: group2,
-          host,
-          obfs,
-          password,
-          port,
-          remark: ps,
-          scv,
-          server,
-          tfo,
-          udp,
-          underlyingProxy,
-          version: toInt(version)
-        });
-        break;
-      }
-      case "wireguard": {
-        group2 = DEFAULT_GROUPS.wireguard;
-        const publicKey = asString(get(single, "public-key"));
-        const privateKey = asString(get(single, "private-key"));
-        const dns = get(single, "dns");
-        const dnsServers = Array.isArray(dns) ? dns.map((d) => String(d)) : dns ? [String(dns)] : [];
-        const mtu = asString(get(single, "mtu"));
-        const psk = asString(get(single, "preshared-key"));
-        const ip = asString(get(single, "ip"));
-        const ipv6 = asString(get(single, "ipv6"));
-        wireGuardConstruct(node, {
-          dnsServers,
-          group: group2,
-          keepAlive: "0",
-          mtu,
-          port,
-          preSharedKey: psk,
-          privateKey,
-          publicKey,
-          remark: ps,
-          selfIp: ip,
-          selfIpv6: ipv6,
-          server,
-          testUrl: "",
-          udp,
-          underlyingProxy
-        });
-        break;
-      }
-      case "hysteria": {
-        group2 = DEFAULT_GROUPS.hysteria;
-        const ports = asString(get(single, "ports"));
-        const protocol = asString(get(single, "protocol"));
-        const obfsProtocol = asString(get(single, "obfs-protocol"));
-        const up = asString(get(single, "up"));
-        const upSpeed = asString(get(single, "up-speed"));
-        const down = asString(get(single, "down"));
-        const downSpeed = asString(get(single, "down-speed"));
-        const auth = asString(get(single, "auth"));
-        let authStr = asString(get(single, "auth-str"));
-        if (authStr === "") {
-          authStr = asString(get(single, "auth_str"));
+      } else if (get(single, "obfs") !== void 0) {
+        plugin = "obfs-local";
+        pluginMode = asString(get(single, "obfs"));
+        pluginHost = asString(get(single, "obfs-host"));
+      }
+      if (plugin === "simple-obfs" || plugin === "obfs-local") {
+        pluginOption = `obfs=${pluginMode}`;
+        pluginOption += pluginHost === "" ? "" : `;obfs-host=${pluginHost}`;
+      } else if (plugin === "v2ray-plugin") {
+        pluginOption = `mode=${pluginMode};${pluginTls}${pluginMux}`;
+        if (pluginHost !== "") {
+          pluginOption += `host=${pluginHost};`;
         }
-        const obfs = asString(get(single, "obfs"));
-        const sni = asString(get(single, "sni"));
-        const fingerprint = asString(get(single, "fingerprint"));
-        const alpnValue = get(single, "alpn");
-        const alpn = Array.isArray(alpnValue) ? asString(alpnValue[0]) : asString(alpnValue);
-        const ca = asString(get(single, "ca"));
-        const caStr = asString(get(single, "ca-str"));
-        const recvWindowConn = asString(get(single, "recv-window-conn"));
-        const recvWindow = asString(get(single, "recv-window"));
-        let disableMtuDiscovery = asString(get(single, "disable-mtu-discovery"));
-        if (disableMtuDiscovery === "") {
-          disableMtuDiscovery = asString(get(single, "disable_mtu_discovery"));
+        if (path !== "") {
+          pluginOption += `path=${path};`;
         }
-        const hopInterval = asString(get(single, "hop-interval"));
-        hysteriaConstruct(node, {
-          alpn,
-          auth,
-          authStr,
-          ca,
-          caStr,
-          disableMtuDiscovery,
-          down,
-          downSpeed,
-          fingerprint,
-          group: group2,
-          hopInterval,
-          obfs,
-          obfsProtocol,
-          port,
-          ports,
-          protocol,
-          recvWindow,
-          recvWindowConn,
-          remark: ps,
-          scv,
-          server,
-          sni,
-          tfo,
-          underlyingProxy,
-          up,
-          upSpeed
-        });
-        break;
-      }
-      case "hysteria2": {
-        group2 = DEFAULT_GROUPS.hysteria2;
-        const ports = asString(get(single, "ports"));
-        const up = asString(get(single, "up"));
-        const down = asString(get(single, "down"));
-        let password = asString(get(single, "password"));
-        if (password === "") {
-          password = asString(get(single, "auth"));
+        if (pluginMux !== "") {
+          pluginOption += `mux=${pluginMux};`;
         }
-        const obfs = asString(get(single, "obfs"));
-        const obfsPassword = asString(get(single, "obfs-password"));
-        const sni = asString(get(single, "sni"));
-        const fingerprint = asString(get(single, "fingerprint"));
-        const alpnValue = get(single, "alpn");
-        const alpn = Array.isArray(alpnValue) ? asString(alpnValue[0]) : asString(alpnValue);
-        const ca = asString(get(single, "ca"));
-        const caStr = asString(get(single, "ca-str"));
-        const cwnd = asString(get(single, "cwnd"));
-        const hopInterval = asString(get(single, "hop-interval"));
-        hysteria2Construct(node, {
-          alpn,
-          ca,
-          caStr,
-          cwnd,
-          down,
-          fingerprint,
-          group: group2,
-          hopInterval,
-          obfs,
-          obfsPassword,
-          password,
-          port,
-          ports,
-          remark: ps,
-          scv,
-          server,
-          sni,
-          tfo,
-          underlyingProxy,
-          up
-        });
-        break;
-      }
-      case "anytls": {
-        group2 = DEFAULT_GROUPS.anytls;
-        const password = asString(get(single, "password"));
-        const sni = asString(get(single, "sni"));
-        anyTlsConstruct(node, {
-          group: group2,
-          password,
-          port,
-          remark: ps,
-          scv,
-          server,
-          sni,
-          tfo,
-          udp,
-          underlyingProxy
-        });
-        break;
       }
-      case "vless": {
-        group2 = DEFAULT_GROUPS.v2ray;
-        const userId = asString(get(single, "uuid"));
-        const net = asString(get(single, "network"));
-        const tls = asString(get(single, "tls"));
-        let path = "";
-        let host = "";
-        if (net === "ws") {
-          path = asString(get(get(single, "ws-opts"), "path"));
-          host = asString(get(get(get(single, "ws-opts"), "headers"), "Host"));
-        } else if (net === "grpc") {
-          path = asString(get(get(single, "grpc-opts"), "grpc-service-name"));
-        }
-        const alpnValue = get(single, "alpn");
-        vlessConstruct(node, {
-          alpn: Array.isArray(alpnValue) ? alpnValue.map((a) => String(a)) : void 0,
-          encryption: asString(get(single, "encryption")),
-          fingerprint: asString(get(single, "client-fingerprint")),
-          flow: asString(get(single, "flow")),
-          group: group2,
-          host,
-          network: net,
-          path,
-          port,
-          remark: ps,
-          scv,
-          server,
-          sni: asString(get(single, "servername")),
-          tfo,
-          tls: tls === "true" ? "tls" : "",
-          udp,
-          underlyingProxy,
-          userId
-        });
-        break;
+      if (cipher === "AEAD_CHACHA20_POLY1305") {
+        cipher = "chacha20-ietf-poly1305";
+      } else if (cipher.includes("AEAD")) {
+        cipher = cipher.replace(/AEAD_/g, "").replace(/_/g, "-").toLowerCase();
       }
-      case "tuic": {
-        group2 = DEFAULT_GROUPS.v2ray;
-        const alpnValue = get(single, "alpn");
-        tuicConstruct(node, {
-          alpn: Array.isArray(alpnValue) ? alpnValue.map((a) => String(a)) : void 0,
-          congestionControl: asString(get(single, "congestion-controller")),
-          group: group2,
-          password: asString(get(single, "password")),
-          port,
-          remark: ps,
-          scv,
-          server,
-          sni: asString(get(single, "sni")),
-          tfo,
-          udp,
-          underlyingProxy,
-          userId: asString(get(single, "uuid"))
-        });
-        break;
+      ssConstruct(node, {
+        group: group2,
+        method: cipher,
+        password,
+        plugin,
+        pluginOption,
+        port,
+        remark: ps,
+        scv,
+        server,
+        tfo,
+        udp,
+        underlyingProxy
+      });
+      break;
+    }
+    case "socks5": {
+      group2 = DEFAULT_GROUPS.socks;
+      const user = asString(get(single, "username"));
+      const password = asString(get(single, "password"));
+      socksConstruct(node, {
+        group: group2,
+        password,
+        port,
+        remark: ps,
+        server,
+        underlyingProxy,
+        username: user
+      });
+      break;
+    }
+    case "ssr": {
+      group2 = DEFAULT_GROUPS.ssr;
+      let cipher = asString(get(single, "cipher"));
+      if (cipher === "dummy") {
+        cipher = "none";
+      }
+      const password = asString(get(single, "password"));
+      const protocol = asString(get(single, "protocol"));
+      const obfs = asString(get(single, "obfs"));
+      const protocolParam = get(single, "protocol-param") !== void 0 ? asString(get(single, "protocol-param")) : asString(get(single, "protocolparam"));
+      const obfsParam = get(single, "obfs-param") !== void 0 ? asString(get(single, "obfs-param")) : asString(get(single, "obfsparam"));
+      ssrConstruct(node, {
+        group: group2,
+        method: cipher,
+        obfs,
+        obfsParam,
+        password,
+        port,
+        protocol,
+        protocolParam,
+        remark: ps,
+        scv,
+        server,
+        tfo,
+        udp,
+        underlyingProxy
+      });
+      break;
+    }
+    case "http": {
+      group2 = DEFAULT_GROUPS.http;
+      const user = asString(get(single, "username"));
+      const password = asString(get(single, "password"));
+      const tls = asString(get(single, "tls"));
+      httpConstruct(node, {
+        group: group2,
+        password,
+        port,
+        remark: ps,
+        scv,
+        server,
+        tfo,
+        tls: tls === "true",
+        underlyingProxy,
+        username: user
+      });
+      break;
+    }
+    case "trojan": {
+      group2 = DEFAULT_GROUPS.trojan;
+      const password = asString(get(single, "password"));
+      const host = asString(get(single, "sni"));
+      let net = asString(get(single, "network"));
+      let path = "";
+      switch (net) {
+        case "grpc":
+          path = asString(get(get(single, "grpc-opts"), "grpc-service-name"));
+          break;
+        case "ws":
+          path = asString(get(get(single, "ws-opts"), "path"));
+          break;
+        default:
+          net = "tcp";
+          path = "";
+          break;
       }
-      default:
-        continue;
+      trojanConstruct(node, {
+        group: group2,
+        host,
+        network: net,
+        password,
+        path,
+        port,
+        remark: ps,
+        scv,
+        server,
+        tfo,
+        tlsSecure: true,
+        udp,
+        underlyingProxy
+      });
+      break;
     }
-    node.id = index;
-    nodes.push(node);
-    index += 1;
+    case "snell": {
+      group2 = DEFAULT_GROUPS.snell;
+      const password = asString(get(single, "psk"));
+      const obfs = asString(get(get(single, "obfs-opts"), "mode"));
+      const host = asString(get(get(single, "obfs-opts"), "host"));
+      const version = asString(get(single, "version"));
+      snellConstruct(node, {
+        group: group2,
+        host,
+        obfs,
+        password,
+        port,
+        remark: ps,
+        scv,
+        server,
+        tfo,
+        udp,
+        underlyingProxy,
+        version: toInt(version)
+      });
+      break;
+    }
+    case "wireguard": {
+      group2 = DEFAULT_GROUPS.wireguard;
+      const publicKey = asString(get(single, "public-key"));
+      const privateKey = asString(get(single, "private-key"));
+      const dns = get(single, "dns");
+      const dnsServers = Array.isArray(dns) ? dns.map((d) => String(d)) : dns ? [String(dns)] : [];
+      const mtu = asString(get(single, "mtu"));
+      const psk = asString(get(single, "preshared-key"));
+      const ip = asString(get(single, "ip"));
+      const ipv6 = asString(get(single, "ipv6"));
+      wireGuardConstruct(node, {
+        dnsServers,
+        group: group2,
+        keepAlive: "0",
+        mtu,
+        port,
+        preSharedKey: psk,
+        privateKey,
+        publicKey,
+        remark: ps,
+        selfIp: ip,
+        selfIpv6: ipv6,
+        server,
+        testUrl: "",
+        udp,
+        underlyingProxy
+      });
+      break;
+    }
+    case "hysteria": {
+      group2 = DEFAULT_GROUPS.hysteria;
+      const ports = asString(get(single, "ports"));
+      const protocol = asString(get(single, "protocol"));
+      const obfsProtocol = asString(get(single, "obfs-protocol"));
+      const up = asString(get(single, "up"));
+      const upSpeed = asString(get(single, "up-speed"));
+      const down = asString(get(single, "down"));
+      const downSpeed = asString(get(single, "down-speed"));
+      const auth = asString(get(single, "auth"));
+      let authStr = asString(get(single, "auth-str"));
+      if (authStr === "") {
+        authStr = asString(get(single, "auth_str"));
+      }
+      const obfs = asString(get(single, "obfs"));
+      const sni = asString(get(single, "sni"));
+      const fingerprint = asString(get(single, "fingerprint"));
+      const alpnValue = get(single, "alpn");
+      const alpn = Array.isArray(alpnValue) ? asString(alpnValue[0]) : asString(alpnValue);
+      const ca = asString(get(single, "ca"));
+      const caStr = asString(get(single, "ca-str"));
+      const recvWindowConn = asString(get(single, "recv-window-conn"));
+      const recvWindow = asString(get(single, "recv-window"));
+      let disableMtuDiscovery = asString(get(single, "disable-mtu-discovery"));
+      if (disableMtuDiscovery === "") {
+        disableMtuDiscovery = asString(get(single, "disable_mtu_discovery"));
+      }
+      const hopInterval = asString(get(single, "hop-interval"));
+      hysteriaConstruct(node, {
+        alpn,
+        auth,
+        authStr,
+        ca,
+        caStr,
+        disableMtuDiscovery,
+        down,
+        downSpeed,
+        fingerprint,
+        group: group2,
+        hopInterval,
+        obfs,
+        obfsProtocol,
+        port,
+        ports,
+        protocol,
+        recvWindow,
+        recvWindowConn,
+        remark: ps,
+        scv,
+        server,
+        sni,
+        tfo,
+        underlyingProxy,
+        up,
+        upSpeed
+      });
+      break;
+    }
+    case "hysteria2": {
+      group2 = DEFAULT_GROUPS.hysteria2;
+      const ports = asString(get(single, "ports"));
+      const up = asString(get(single, "up"));
+      const down = asString(get(single, "down"));
+      let password = asString(get(single, "password"));
+      if (password === "") {
+        password = asString(get(single, "auth"));
+      }
+      const obfs = asString(get(single, "obfs"));
+      const obfsPassword = asString(get(single, "obfs-password"));
+      const sni = asString(get(single, "sni"));
+      const fingerprint = asString(get(single, "fingerprint"));
+      const alpnValue = get(single, "alpn");
+      const alpn = Array.isArray(alpnValue) ? asString(alpnValue[0]) : asString(alpnValue);
+      const ca = asString(get(single, "ca"));
+      const caStr = asString(get(single, "ca-str"));
+      const cwnd = asString(get(single, "cwnd"));
+      const hopInterval = asString(get(single, "hop-interval"));
+      hysteria2Construct(node, {
+        alpn,
+        ca,
+        caStr,
+        cwnd,
+        down,
+        fingerprint,
+        group: group2,
+        hopInterval,
+        obfs,
+        obfsPassword,
+        password,
+        port,
+        ports,
+        remark: ps,
+        scv,
+        server,
+        sni,
+        tfo,
+        underlyingProxy,
+        up
+      });
+      break;
+    }
+    case "anytls": {
+      group2 = DEFAULT_GROUPS.anytls;
+      const password = asString(get(single, "password"));
+      const sni = asString(get(single, "sni"));
+      anyTlsConstruct(node, {
+        group: group2,
+        password,
+        port,
+        remark: ps,
+        scv,
+        server,
+        sni,
+        tfo,
+        udp,
+        underlyingProxy
+      });
+      break;
+    }
+    case "vless": {
+      group2 = DEFAULT_GROUPS.v2ray;
+      const userId = asString(get(single, "uuid"));
+      const net = asString(get(single, "network"));
+      const tls = asString(get(single, "tls"));
+      let path = "";
+      let host = "";
+      if (net === "ws") {
+        path = asString(get(get(single, "ws-opts"), "path"));
+        host = asString(get(get(get(single, "ws-opts"), "headers"), "Host"));
+      } else if (net === "grpc") {
+        path = asString(get(get(single, "grpc-opts"), "grpc-service-name"));
+      }
+      const alpnValue = get(single, "alpn");
+      vlessConstruct(node, {
+        alpn: Array.isArray(alpnValue) ? alpnValue.map((a) => String(a)) : void 0,
+        encryption: asString(get(single, "encryption")),
+        fingerprint: asString(get(single, "client-fingerprint")),
+        flow: asString(get(single, "flow")),
+        group: group2,
+        host,
+        network: net,
+        path,
+        port,
+        remark: ps,
+        scv,
+        server,
+        sni: asString(get(single, "servername")),
+        tfo,
+        tls: tls === "true" ? "tls" : "",
+        udp,
+        underlyingProxy,
+        userId
+      });
+      break;
+    }
+    case "tuic": {
+      group2 = DEFAULT_GROUPS.v2ray;
+      const alpnValue = get(single, "alpn");
+      tuicConstruct(node, {
+        alpn: Array.isArray(alpnValue) ? alpnValue.map((a) => String(a)) : void 0,
+        congestionControl: asString(get(single, "congestion-controller")),
+        group: group2,
+        password: asString(get(single, "password")),
+        port,
+        remark: ps,
+        scv,
+        server,
+        sni: asString(get(single, "sni")),
+        tfo,
+        udp,
+        underlyingProxy,
+        userId: asString(get(single, "uuid"))
+      });
+      break;
+    }
+    default:
+      return false;
   }
+  node.id = index;
+  nodes.push(node);
+  return true;
 }
 function parseRawSections(text) {
   const sections = [];
@@ -4133,7 +4217,10 @@ function explodeSs(ss, node) {
     const secret = match[1];
     server = match[2];
     port = match[3];
-    const secretMatch = firstMatch(urlSafeBase64Decode(secret), "(\\S+?):(\\S+)");
+    const raw = urlDecode(secret);
+    const decoded = firstMatch(urlSafeBase64Decode(raw), "(\\S+?):(\\S+)");
+    const plaintext = firstMatch(raw, "(\\S+?):(\\S+)");
+    const secretMatch = decoded && isSsCipher(decoded[1]) ? decoded : plaintext ?? decoded;
     if (!secretMatch) {
       return;
     }
@@ -4598,6 +4685,157 @@ function explodeAnyTls(link, node) {
     udp: udp === "" ? void 0 : parseTri(udp)
   });
 }
+function explodeSnell(link, node) {
+  let body = link.slice(8);
+  let remark = "";
+  let addition = "";
+  const hashPos = body.lastIndexOf("#");
+  if (hashPos !== -1) {
+    remark = urlDecode(body.slice(hashPos + 1));
+    body = body.slice(0, hashPos);
+  }
+  const qpos = body.lastIndexOf("?");
+  if (qpos !== -1) {
+    addition = body.slice(qpos + 1);
+    body = body.slice(0, qpos);
+  }
+  const match = /^(.*?)@(.*)[:](\d+)$/.exec(body);
+  if (!match) {
+    return;
+  }
+  const password = match[1];
+  const server = match[2];
+  const port = match[3];
+  if (password === "" || port === "" || port === "0") {
+    return;
+  }
+  const obfs = getUrlArg(addition, "obfs");
+  const host = getUrlArg(addition, "host");
+  const version = getUrlArg(addition, "version");
+  const udp = getUrlArg(addition, "udp");
+  const tfo = getUrlArg(addition, "tfo");
+  const scv = getUrlArg(addition, "skip-cert-verify");
+  if (remark === "") {
+    remark = `${server}:${port}`;
+  }
+  snellConstruct(node, {
+    group: DEFAULT_GROUPS.snell,
+    host,
+    obfs: obfs === "" ? "none" : obfs,
+    password,
+    port,
+    remark,
+    scv: scv === "" ? void 0 : parseTri(scv),
+    server,
+    tfo: tfo === "" ? void 0 : parseTri(tfo),
+    udp: udp === "" ? void 0 : parseTri(udp),
+    version: version === "" ? 1 : toInt(version)
+  });
+}
+function explodeHysteria(link, node) {
+  let body = link.slice(11);
+  let remark = "";
+  let addition = "";
+  const hashPos = body.lastIndexOf("#");
+  if (hashPos !== -1) {
+    remark = urlDecode(body.slice(hashPos + 1));
+    body = body.slice(0, hashPos);
+  }
+  const qpos = body.lastIndexOf("?");
+  if (qpos !== -1) {
+    addition = body.slice(qpos + 1);
+    body = body.slice(0, qpos);
+  }
+  const match = /^(.*)[:](\d+)$/.exec(body);
+  if (!match) {
+    return;
+  }
+  const server = match[1];
+  const port = match[2];
+  if (server === "" || port === "0") {
+    return;
+  }
+  const auth = getUrlArg(addition, "auth");
+  const protocol = getUrlArg(addition, "protocol");
+  const upSpeed = getUrlArg(addition, "upmbps");
+  const downSpeed = getUrlArg(addition, "downmbps");
+  const alpn = getUrlArg(addition, "alpn");
+  const obfs = getUrlArg(addition, "obfs");
+  const obfsProtocol = getUrlArg(addition, "obfsParam");
+  const sni = getUrlArg(addition, "peer");
+  const insecure = getUrlArg(addition, "insecure");
+  if (remark === "") {
+    remark = `${server}:${port}`;
+  }
+  hysteriaConstruct(node, {
+    alpn,
+    authStr: auth,
+    downSpeed,
+    group: DEFAULT_GROUPS.hysteria,
+    obfs,
+    obfsProtocol,
+    port,
+    protocol: protocol === "" ? "udp" : protocol,
+    remark,
+    scv: insecure === "" ? void 0 : parseTri(insecure),
+    server,
+    sni: sni === "" ? server : sni,
+    upSpeed
+  });
+}
+function explodeWireguard(link, node) {
+  const normalized = link.replace(/^(wg|wireguard):\/\//, "wireguard://");
+  let body = normalized.slice(13);
+  let remark = "";
+  let addition = "";
+  const hashPos = body.lastIndexOf("#");
+  if (hashPos !== -1) {
+    remark = urlDecode(body.slice(hashPos + 1));
+    body = body.slice(0, hashPos);
+  }
+  const qpos = body.lastIndexOf("?");
+  if (qpos !== -1) {
+    addition = body.slice(qpos + 1);
+    body = body.slice(0, qpos);
+  }
+  const match = /^(?:(.*)@)?\[?(.*?)]?:(\d+)$/.exec(body);
+  if (!match) {
+    return;
+  }
+  const server = match[2];
+  const port = match[3];
+  if (server === "" || port === "0") {
+    return;
+  }
+  const privateKey = getUrlArg(addition, "privateKey") || getUrlArg(addition, "privatekey");
+  const publicKey = getUrlArg(addition, "publicKey") || getUrlArg(addition, "publickey");
+  if (privateKey === "" || publicKey === "") {
+    return;
+  }
+  const presharedKey = getUrlArg(addition, "presharedKey");
+  const selfIp = getUrlArg(addition, "selfIP");
+  const selfIpv6 = getUrlArg(addition, "selfIPv6");
+  const mtu = getUrlArg(addition, "mtu");
+  const keepAlive = getUrlArg(addition, "keepAlive");
+  const dns = getUrlArg(addition, "dns");
+  if (remark === "") {
+    remark = `${server}:${port}`;
+  }
+  wireGuardConstruct(node, {
+    dnsServers: dns === "" ? ["1.1.1.1"] : dns.split(",").map((s) => s.trim()),
+    group: DEFAULT_GROUPS.wireguard,
+    keepAlive: keepAlive === "" ? 25 : toInt(keepAlive),
+    mtu: mtu === "" ? 1420 : toInt(mtu),
+    port,
+    preSharedKey: presharedKey,
+    privateKey,
+    publicKey,
+    remark,
+    selfIp: selfIp === "" ? "10.0.0.2" : selfIp,
+    selfIpv6,
+    server
+  });
+}
 function explodeVless(link, node) {
   let body = link.slice(8);
   let remark = "";
@@ -4721,6 +4959,12 @@ function explode(link, node) {
     explodeVless(link, node);
   } else if (startsWith(link, "tuic://")) {
     explodeTuic(link, node);
+  } else if (startsWith(link, "snell://")) {
+    explodeSnell(link, node);
+  } else if (startsWith(link, "hysteria://")) {
+    explodeHysteria(link, node);
+  } else if (startsWith(link, "wg://") || startsWith(link, "wireguard://")) {
+    explodeWireguard(link, node);
   } else if (link.includes("hysteria2://") || link.includes("hy2://")) {
     explodeHysteria2(link, node);
   } else if (startsWith(link, "anytls://")) {
@@ -5117,7 +5361,11 @@ function normalizeRegionCode(code) {
   const upper = code.trim().toUpperCase();
   return /^[A-Z]{2}$/.test(upper) ? upper : "";
 }
-function regionDisplayName(code, locale = "zh-CN") {
+function normalizeCountryCode(code) {
+  const upper = normalizeRegionCode(code);
+  return upper !== "" && isRegionCode(upper) ? upper : void 0;
+}
+function displayName(code, locale) {
   const upper = normalizeRegionCode(code);
   if (upper === "") {
     return code.trim();
@@ -5160,8 +5408,8 @@ function buildAliasRegex() {
     }
   };
   for (const code of REGION_CODES) {
-    add(regionDisplayName(code, "zh-CN"));
-    add(regionDisplayName(code, "en"));
+    add(displayName(code, "zh-CN"));
+    add(displayName(code, "en"));
     add(regionFlag(code));
   }
   for (const alias of EXTRA_ALIASES) {
@@ -5201,13 +5449,13 @@ function hasRegionName(remark) {
   }
   return false;
 }
-function formatCountryRemark(remark, code, locale = "zh-CN") {
-  const name = regionDisplayName(code, locale);
+function formatCountryRemark(remark, code) {
+  const normalized = normalizeCountryCode(code);
   const trimmed = remark.trim();
-  if (name === "") {
+  if (normalized === void 0) {
     return trimmed;
   }
-  return trimmed === "" ? name : `${name}-${trimmed}`;
+  return trimmed === "" ? normalized : `${normalized}-${trimmed}`;
 }
 
 // src/generator/nodes.ts
@@ -5221,6 +5469,10 @@ function toRegex(pattern) {
 function regFind(value, pattern) {
   return toRegex(pattern).test(value);
 }
+var REGEX_BLACKLIST = ["(.*)*"];
+function isBlacklistedPattern(pattern) {
+  return REGEX_BLACKLIST.includes(pattern);
+}
 function regMatch2(value, pattern) {
   const match = toRegex(pattern).exec(value);
   return match !== null && match[0] === value;
@@ -5466,7 +5718,7 @@ function nodeRename(node, renameArray) {
     node.remark = original;
   }
 }
-function addCountryPrefix(node, resolve, locale = "zh-CN") {
+function addCountryPrefix(node, resolve) {
   const remark = node.remark.trim();
   if (hasRegionName(remark)) {
     return node.remark;
@@ -5475,7 +5727,31 @@ function addCountryPrefix(node, resolve, locale = "zh-CN") {
   if (code === void 0 || code === "") {
     return node.remark;
   }
-  return formatCountryRemark(remark, code, locale);
+  return formatCountryRemark(remark, code);
+}
+function filterNodesByCountry(nodes, resolve, include, exclude) {
+  const includeSet = new Set(
+    include.map((code) => normalizeCountryCode(code)).filter((code) => code !== void 0)
+  );
+  const excludeSet = new Set(
+    exclude.map((code) => normalizeCountryCode(code)).filter((code) => code !== void 0)
+  );
+  if (includeSet.size === 0 && excludeSet.size === 0) {
+    return;
+  }
+  const kept = [];
+  for (const node of nodes) {
+    const code = resolve ? normalizeCountryCode(resolve(node) ?? "") : void 0;
+    if (includeSet.size > 0 && (code === void 0 || !includeSet.has(code))) {
+      continue;
+    }
+    if (code !== void 0 && excludeSet.has(code)) {
+      continue;
+    }
+    kept.push(node);
+  }
+  nodes.length = 0;
+  nodes.push(...kept);
 }
 function preprocessNodes(nodes, options) {
   for (const node of nodes) {
@@ -5493,13 +5769,25 @@ function preprocessNodes(nodes, options) {
       node.remark = addEmoji(node, options.emojiArray);
     }
     if (options.autoCountry && options.countryResolver) {
-      node.remark = addCountryPrefix(
-        node,
-        options.countryResolver,
-        options.countryLocale ?? "zh-CN"
-      );
+      node.remark = addCountryPrefix(node, options.countryResolver);
     }
   }
+  filterNodesByCountry(
+    nodes,
+    options.countryResolver,
+    options.includeCountries ?? [],
+    options.excludeCountries ?? []
+  );
+  const includeRemarks = options.includeRemarks ?? [];
+  const excludeRemarks = options.excludeRemarks ?? [];
+  if (includeRemarks.length > 0 || excludeRemarks.length > 0) {
+    const kept = nodes.filter((node) => !checkIgnore(node, excludeRemarks, includeRemarks));
+    kept.forEach((node, index) => {
+      node.id = index;
+    });
+    nodes.length = 0;
+    nodes.push(...kept);
+  }
   if (options.sortFlag) {
     nodes.sort((a, b) => a.remark < b.remark ? -1 : a.remark > b.remark ? 1 : 0);
   }
@@ -5556,12 +5844,59 @@ function stripBrackets(value) {
 function toTri(value) {
   return value;
 }
+var MIHOMO_PROTOCOLS = /* @__PURE__ */ new Set([
+  "ss" /* Shadowsocks */,
+  "ssr" /* ShadowsocksR */,
+  "vmess" /* VMess */,
+  "trojan" /* Trojan */,
+  "snell" /* Snell */,
+  "http" /* HTTP */,
+  "https" /* HTTPS */,
+  "socks5" /* SOCKS5 */,
+  "wireguard" /* WireGuard */,
+  "hysteria" /* Hysteria */,
+  "hysteria2" /* Hysteria2 */,
+  "vless" /* VLESS */,
+  "anytls" /* AnyTLS */,
+  "tuic" /* TUIC */
+]);
+var PREMIUM_PROTOCOLS = /* @__PURE__ */ new Set([
+  "ss" /* Shadowsocks */,
+  "ssr" /* ShadowsocksR */,
+  "vmess" /* VMess */,
+  "trojan" /* Trojan */,
+  "snell" /* Snell */,
+  "http" /* HTTP */,
+  "https" /* HTTPS */,
+  "socks5" /* SOCKS5 */,
+  "wireguard" /* WireGuard */
+]);
+var STASH_PROTOCOLS = /* @__PURE__ */ new Set([
+  ...PREMIUM_PROTOCOLS,
+  "hysteria" /* Hysteria */,
+  "hysteria2" /* Hysteria2 */,
+  "vless" /* VLESS */,
+  "tuic" /* TUIC */
+]);
+function clashCapabilities(flavor) {
+  if (flavor === "premium") {
+    return { clientFingerprint: false, protocols: PREMIUM_PROTOCOLS, reality: false };
+  }
+  if (flavor === "stash") {
+    return { clientFingerprint: false, protocols: STASH_PROTOCOLS, reality: true };
+  }
+  return { clientFingerprint: true, protocols: MIHOMO_PROTOCOLS, reality: true };
+}
 function buildClashProxy(x, settings, clashR, remark, skipCertVerify, tfo) {
   const proxy = {
     name: remark,
     port: x.port,
     server: stripBrackets(x.hostname)
   };
+  const caps = clashCapabilities(settings.clashFlavor);
+  if (!caps.protocols.has(x.type)) {
+    return void 0;
+  }
   switch (x.type) {
     case "ss" /* Shadowsocks */: {
       if (settings.filterDeprecated && x.encryptMethod === "chacha20") {
@@ -5811,7 +6146,7 @@ function buildClashProxy(x, settings, clashR, remark, skipCertVerify, tfo) {
       if (skipCertVerify !== void 0) {
         proxy["skip-cert-verify"] = skipCertVerify;
       }
-      if (x.fingerprint !== "") {
+      if (x.fingerprint !== "" && caps.clientFingerprint) {
         proxy.fingerprint = x.fingerprint;
       }
       if (x.alpn.length > 0) {
@@ -5866,7 +6201,7 @@ function buildClashProxy(x, settings, clashR, remark, skipCertVerify, tfo) {
       if (skipCertVerify !== void 0) {
         proxy["skip-cert-verify"] = skipCertVerify;
       }
-      if (x.fingerprint !== "") {
+      if (x.fingerprint !== "" && caps.clientFingerprint) {
         proxy.fingerprint = x.fingerprint;
       }
       if (x.alpn.length > 0) {
@@ -5905,10 +6240,13 @@ function buildClashProxy(x, settings, clashR, remark, skipCertVerify, tfo) {
       if (x.serverName !== "") {
         proxy.servername = x.serverName;
       }
-      if (x.fingerprint !== "") {
+      if (x.fingerprint !== "" && caps.clientFingerprint) {
         proxy["client-fingerprint"] = x.fingerprint;
       }
       if (x.publicKey !== "" || x.shortId !== "") {
+        if (!caps.reality) {
+          return void 0;
+        }
         const realityOpts = {};
         if (x.publicKey !== "") {
           realityOpts["public-key"] = x.publicKey;
@@ -7265,7 +7603,7 @@ function collectRuleLines(content, group2, noResolveOnly) {
   }
   return out;
 }
-function rulesetToClashRules(rulesets) {
+function rulesetToClashRules(rulesets, classical = false) {
   const rules = [];
   for (const ruleset of rulesets) {
     const content = ruleset.content;
@@ -7281,7 +7619,10 @@ function rulesetToClashRules(rulesets) {
       rules.push(transformRuleToCommon(line, group2));
       continue;
     }
-    const converted = convertRuleset(content, ruleset.ruleType);
+    const converted = convertRuleset(
+      content,
+      classical && /^payload:\r?\n/.test(content) ? "clash-classical" /* ClashClassical */ : ruleset.ruleType
+    );
     for (const rawLine of converted.split(/\r?\n/)) {
       let line = rawLine.trim();
       if (!isRuleLine(line)) {
@@ -7298,7 +7639,7 @@ function rulesetToClashRules(rulesets) {
   }
   return rules;
 }
-function rulesetToSurgeRules(rulesets, surgeVersion) {
+function rulesetToSurgeRules(rulesets, surgeVersion, expand = true) {
   let section;
   let allowed;
   let noResolveOnly = false;
@@ -7336,6 +7677,17 @@ function rulesetToSurgeRules(rulesets, surgeVersion) {
       continue;
     }
     const group2 = ruleset.ruleGroup;
+    if (!expand && (surgeVersion > 2 || surgeVersion === -3)) {
+      const { url } = parseRulesetSource(ruleset.rulePath);
+      if (/^https?:\/\//i.test(url.trim()) && !ruleset.content.startsWith("[]")) {
+        let line = `RULE-SET,${url.trim()},${group2}`;
+        if (ruleset.updateInterval > 0) {
+          line += `,update-interval=${ruleset.updateInterval}`;
+        }
+        lines.push(line);
+        continue;
+      }
+    }
     if (ruleset.content.startsWith("[]")) {
       let line = ruleset.content.slice(2);
       if (line === "MATCH") {
@@ -8100,9 +8452,24 @@ function buildOutbound(x, settings, remark) {
       proxy = out;
       break;
     }
-    // sing-box has no SSR support — drop such nodes.
+    // sing-box has no ShadowsocksR implementation (configs using it fail
+    // at startup), so such nodes are dropped.
     case "ssr" /* ShadowsocksR */:
       return void 0;
+    case "snell" /* Snell */: {
+      const out = { ...common, psk: x.password, type: "snell" };
+      if (x.snellVersion) {
+        out.version = x.snellVersion;
+      }
+      if (x.obfs !== "" && x.obfs !== "none") {
+        out.obfs_mode = x.obfs;
+      }
+      if (x.host !== "") {
+        out.obfs_host = x.host;
+      }
+      proxy = out;
+      break;
+    }
     case "vmess" /* VMess */: {
       const out = {
         ...common,
@@ -8385,9 +8752,12 @@ function runPreprocess(nodes, settings) {
   preprocessNodes(nodes, {
     addEmoji: settings.addEmoji,
     autoCountry: settings.autoCountry,
-    countryLocale: settings.countryLocale,
     countryResolver: settings.countryResolver,
     emojiArray: settings.emojiArray,
+    excludeCountries: settings.excludeCountries,
+    excludeRemarks: settings.excludeRemarks,
+    includeCountries: settings.includeCountries,
+    includeRemarks: settings.includeRemarks,
     nameRegexArray: settings.nameRegexArray,
     nameRemove: settings.nameRemove,
     removeEmoji: settings.removeEmoji,
@@ -8403,6 +8773,7 @@ function generate(nodes, options) {
   runPreprocess(nodes, settings);
   const groups = resolveGroups(options);
   const rulesets = resolveRulesets(options, settings);
+  const baseConf = applyBaseTemplate(options.baseConf ?? "", settings);
   switch (options.target) {
     case "clash" /* Clash */:
     case "clashr" /* ClashR */: {
@@ -8412,9 +8783,9 @@ function generate(nodes, options) {
     }
     case "surge" /* Surge */: {
       const surgeVersion = options.surgeVersion ?? 5;
-      const rules = rulesets ? rulesetToSurgeRules(rulesets, surgeVersion) : void 0;
+      const rules = rulesets ? rulesetToSurgeRules(rulesets, surgeVersion, settings.expandRulesets) : void 0;
       return toSurge(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         rules,
         version: surgeVersion
@@ -8423,7 +8794,7 @@ function generate(nodes, options) {
     case "quanx" /* QuantumultX */: {
       const rules = rulesets ? rulesetToSurgeRules(rulesets, -1) : void 0;
       return toQuanX(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         rules
       });
@@ -8431,7 +8802,7 @@ function generate(nodes, options) {
     case "quan" /* Quantumult */: {
       const rules = rulesets ? rulesetToSurgeRules(rulesets, -2) : void 0;
       return toQuan(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         rules
       });
@@ -8439,21 +8810,21 @@ function generate(nodes, options) {
     case "loon" /* Loon */: {
       const rules = rulesets ? rulesetToSurgeRules(rulesets, -4) : void 0;
       return toLoon(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         rules
       });
     }
     case "singbox" /* SingBox */:
       return toSingBox(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         overwriteOriginalRules: settings.overwriteOriginalRules,
         rulesets
       });
     case "mellow" /* Mellow */:
       return toMellow(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         overwriteOriginalRules: settings.overwriteOriginalRules,
         rulesets
@@ -8471,11 +8842,11 @@ function generate(nodes, options) {
     case "ssd" /* SSD */:
       return proxyToSsd(nodes, "", "");
     case "sssub" /* SSSub */:
-      return proxyToSsSub(nodes, options.baseConf ?? "");
+      return proxyToSsSub(nodes, baseConf);
     case "surfboard" /* Surfboard */: {
-      const rules = rulesets ? rulesetToSurgeRules(rulesets, options.surgeVersion ?? 5) : void 0;
+      const rules = rulesets ? rulesetToSurgeRules(rulesets, options.surgeVersion ?? 5, settings.expandRulesets) : void 0;
       return toSurfboard(nodes, groups, settings, {
-        baseConf: options.baseConf ?? "",
+        baseConf,
         nodeList: settings.nodeList,
         rules
       });
@@ -8488,6 +8859,12 @@ function generate(nodes, options) {
       throw new Error(`Unsupported target format: ${options.target}`);
   }
 }
+function applyBaseTemplate(baseConf, settings) {
+  if (baseConf === "" || !hasTemplatePlaceholders(baseConf)) {
+    return baseConf;
+  }
+  return renderTemplate(baseConf, settings.templateVars);
+}
 function toSip008(nodes, baseConf = "") {
   return proxyToSsSub(nodes, baseConf);
 }
@@ -8517,7 +8894,7 @@ function attachClashRules(doc, settings, rulesets) {
     return;
   }
   const field = settings.clashNewFieldName ? "rules" : "Rule";
-  const generated = rulesetToClashRules(rulesets);
+  const generated = rulesetToClashRules(rulesets, settings.clashClassicalRuleset);
   if (generated.length === 0) {
     return;
   }