@subconverter/core 0.2.1 → 0.4.0

package/dist/index.js

@@ -219,6 +219,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";
@@ -247,16 +257,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: [],
@@ -269,6 +284,7 @@ function createExtraSettings() {
     sortFlag: false,
     sortScript: "",
     surgeSsrPath: "",
+    templateVars: {},
     tfo: void 0,
     tls13: void 0,
     udp: void 0
@@ -492,7 +508,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);
@@ -641,6 +657,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 */,
@@ -742,8 +775,10 @@ function parseExternalConfig(content) {
     baseFiles: {},
     emoji: [],
     enableRuleGenerator: true,
+    excludeCountries: [],
     excludeRemarks: [],
     groups: [],
+    includeCountries: [],
     includeRemarks: [],
     nameRegex: [],
     nameRemove: [],
@@ -812,6 +847,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 !== "") {
@@ -866,6 +917,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;
@@ -904,13 +958,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,
@@ -928,6 +988,7 @@ function createRequestSettings() {
     script: "",
     scv: void 0,
     sort: false,
+    strict: false,
     target: "auto" /* Auto */,
     tfo: void 0,
     tls13: void 0,
@@ -956,6 +1017,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");
@@ -971,6 +1037,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,
@@ -1846,485 +1914,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 = [];
@@ -3932,7 +4008,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;
     }
@@ -4397,6 +4476,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 = "";
@@ -4520,6 +4750,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://")) {
@@ -4916,7 +5152,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();
@@ -4959,8 +5199,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) {
@@ -5000,13 +5240,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
@@ -5020,6 +5260,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;
@@ -5265,7 +5509,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;
@@ -5274,7 +5518,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) {
@@ -5292,13 +5560,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);
   }
@@ -5355,12 +5635,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") {
@@ -5610,7 +5937,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) {
@@ -5665,7 +5992,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) {
@@ -5704,10 +6031,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;
@@ -7064,7 +7394,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;
@@ -7080,7 +7410,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)) {
@@ -7097,7 +7430,7 @@ function rulesetToClashRules(rulesets) {
   }
   return rules;
 }
-function rulesetToSurgeRules(rulesets, surgeVersion) {
+function rulesetToSurgeRules(rulesets, surgeVersion, expand = true) {
   let section;
   let allowed;
   let noResolveOnly = false;
@@ -7135,6 +7468,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") {
@@ -7899,9 +8243,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,
@@ -8184,9 +8543,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,
@@ -8202,6 +8564,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 */: {
@@ -8211,9 +8574,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
@@ -8222,7 +8585,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
       });
@@ -8230,7 +8593,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
       });
@@ -8238,21 +8601,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
@@ -8270,11 +8633,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
       });
@@ -8287,6 +8650,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);
 }
@@ -8316,7 +8685,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;
   }
@@ -8334,6 +8703,8 @@ export {
   ProxyGroupType,
   ProxyType,
   QUANX_RULE_TYPES,
+  REGEX_BLACKLIST,
+  RULESET_TYPE_PREFIXES,
   RulesetType,
   SING_BOX_RULE_TYPES,
   SSR_CIPHERS,
@@ -8365,12 +8736,14 @@ export {
   explodeClash,
   explodeHttp,
   explodeHttpSub,
+  explodeHysteria,
   explodeHysteria2,
   explodeKitsunebi,
   explodeNetch,
   explodeNetchConf,
   explodeQuan,
   explodeShadowrocket,
+  explodeSnell,
   explodeSocks,
   explodeSs,
   explodeSsAndroid,
@@ -8387,7 +8760,9 @@ export {
   explodeVless,
   explodeVmess,
   explodeVmessConf,
+  explodeWireguard,
   filterNodes,
+  filterNodesByCountry,
   findSection,
   fnv1a64,
   fnv1a64Hex,
@@ -8409,6 +8784,7 @@ export {
   hysteria2Construct,
   hysteriaConstruct,
   inferUserinfoProviderFromUrl,
+  isBlacklistedPattern,
   isBlank,
   isFlattenableSsr,
   isIp,
@@ -8422,9 +8798,11 @@ export {
   nodeNameRegex,
   nodeNameRemove,
   nodeRename,
+  normalizeCountryCode,
   normalizeQueryKey,
   normalizeUserinfoProvider,
   pad2,
+  parseClashFlavor,
   parseClashText,
   parseConfContent,
   parseCustomProxyGroup,
@@ -8439,6 +8817,7 @@ export {
   parseRegexMatch,
   parseRequestSettings,
   parseRulesetConfig,
+  parseRulesetSource,
   parseSubscription,
   parseSubscriptionUserinfo,
   parseTriBool,
@@ -8451,8 +8830,6 @@ export {
   queryBoolFlag,
   regMatch,
   regReplace,
-  regionDisplayName,
-  regionFlag,
   removeEmoji,
   renderRawIni,
   renderTemplate,