Update API documentation to reflect changes in configuration format for GET /convert/:config, including detailed descriptions of new parameters and structures for config, RuleProvider, and Rule.

Refactor subscription handling by removing SubConfig model, updating BuildSub function to use ConvertConfig, and enhancing Base64 decoding across parsers. Update routes and frontend to support new configuration format.
Implement YAML unmarshalling for various proxy types and update SOCKS parser to support "socks5" prefix.
2025-11-03 20:30:35 +00:00 · 2025-07-22 04:19:26 +00:00 · 2025-07-22 04:09:00 +00:00 · 2025-07-15 20:14:37 +08:00 · 2025-07-13 22:49:33 +08:00 · 2025-07-13 15:57:46 +08:00
33 changed files with 787 additions and 583 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,6 @@ logs
 data
 .env
 .vscode/settings.json
+config.yaml
+config.yml
+config.json
--- a/API.md
+++ b/API.md
@@ -1,21 +1,48 @@
-# `GET /clash`, `GET /meta`
+# `GET /convert/:config`

 获取 Clash/Clash.Meta 配置链接

+| Path 参数 | 类型   | 说明                                           |
+| --------- | ------ | ---------------------------------------------- |
+| config    | string | Base64 URL Safe 编码后的 JSON 字符串，格式如下 |
+
+## `config` JSON 结构
+
 | Query 参数         | 类型              | 是否必须                 | 默认值    | 说明                                                                              |
-| ------------ | ------ | ------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| sub          | string | sub/proxy 至少有一项存在 | -         | 订阅链接，可以在链接结尾加上`#名称`，来给订阅中的节点加上统一前缀（可以输入多个，用 `,` 分隔）                                                                                                                                            |
-| proxy        | string | sub/proxy 至少有一项存在 | -         | 节点分享链接（可以输入多个，用 `,` 分隔）                                                                                                                                                                                                 |
+| ------------------ | ----------------- | ------------------------ | --------- | --------------------------------------------------------------------------------- |
+| clashType          | int               | 是                       | 1         | 配置文件类型 (1: Clash, 2: Clash.Meta)                                            |
+| subscriptions      | []string          | sub/proxy 至少有一项存在 | -         | 订阅链接，可以在链接结尾加上`#名称`，来给订阅中的节点加上统一前缀（可以输入多个） |
+| proxies            | []string          | sub/proxy 至少有一项存在 | -         | 节点分享链接（可以输入多个）                                                      |
 | refresh            | bool              | 否                       | `false`   | 强制刷新配置（默认缓存 5 分钟）                                                   |
 | template           | string            | 否                       | -         | 外部模板链接或内部模板名称                                                        |
-| ruleProvider | string | 否                       | -         | 格式 `[Behavior,Url,Group,Prepend,Name],[Behavior,Url,Group,Prepend,Name]...`，其中 `Group` 是该规则集使用的策略组名，`Prepend` 为 bool 类型，如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部（会调整到 MATCH 规则之前） |
-| rule         | string | 否                       | -         | 格式 `[Rule,Prepend],[Rule,Prepend]...`，其中 `Prepend` 为 bool 类型，如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部（会调整到 MATCH 规则之前）                                                                         |
+| ruleProviders      | []RuleProvider    | 否                       | -         | 规则                                                                              |
+| rules              | []Rule            | 否                       | -         | 规则                                                                              |
 | autoTest           | bool              | 否                       | `false`   | 国家策略组是否自动测速                                                            |
 | lazy               | bool              | 否                       | `false`   | 自动测速是否启用 lazy                                                             |
 | sort               | string            | 否                       | `nameasc` | 国家策略组排序策略，可选值 `nameasc`、`namedesc`、`sizeasc`、`sizedesc`           |
-| replace      | string | 否                       | -         | 通过正则表达式重命名节点，格式 `[<ReplaceKey>,<ReplaceTo>],[<ReplaceKey>,<ReplaceTo>]...`                                                                                                                                                 |
+| replace            | map[string]string | 否                       | -         | 通过正则表达式重命名节点                                                          |
 | remove             | string            | 否                       | -         | 通过正则表达式删除节点                                                            |
 | nodeList           | bool              | 否                       | `false`   | 只输出节点                                                                        |
+| ignoreCountryGroup | bool              | 否                       | `false`   | 是否忽略国家分组                                                                  |
+| userAgent          | string            | 否                       | -         | 订阅 user-agent                                                                   |
+| useUDP             | bool              | 否                       | `false`   | 是否使用 UDP                                                                      |
+
+### `RuleProvider` 结构
+
+| 字段     | 类型   | 说明                                                             |
+| -------- | ------ | ---------------------------------------------------------------- |
+| behavior | string | rule-set 的 behavior                                             |
+| url      | string | rule-set 的 url                                                  |
+| group    | string | 该规则集使用的策略组名                                           |
+| prepend  | bool   | 如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部 |
+| name     | string | 该 rule-provider 的名称，不能重复                                |
+
+### `Rule` 结构
+
+| 字段    | 类型   | 说明                                                             |
+| ------- | ------ | ---------------------------------------------------------------- |
+| rule    | string | 规则                                                             |
+| prepend | bool   | 如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部 |

 # `POST /short`

--- a/common/sub.go
+++ b/common/sub.go
@@ -19,6 +19,7 @@ import (
 	"github.com/bestnite/sub2clash/model"
 	P "github.com/bestnite/sub2clash/model/proxy"
 	"github.com/bestnite/sub2clash/parser"
+	"github.com/bestnite/sub2clash/utils"
 	"go.uber.org/zap"
 	"gopkg.in/yaml.v3"
 )
@@ -92,7 +93,7 @@ func FetchSubscriptionFromAPI(url string, userAgent string, retryTimes int) ([]b
 	return data, nil
 }

-func BuildSub(clashType model.ClashType, query model.SubConfig, template string, cacheExpire int64, retryTimes int) (
+func BuildSub(clashType model.ClashType, query model.ConvertConfig, template string, cacheExpire int64, retryTimes int) (
 	*model.Subscription, error,
 ) {
 	var temp = &model.Subscription{}
@@ -154,13 +155,13 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 				return nil, NewRegexInvalidError("prefix", err)
 			}
 			if reg.Match(data) {
-				p, err := parser.ParseProxies(strings.Split(string(data), "\n")...)
+				p, err := parser.ParseProxies(parser.ParseConfig{UseUDP: query.UseUDP}, strings.Split(string(data), "\n")...)
 				if err != nil {
 					return nil, err
 				}
 				newProxies = p
 			} else {
-				base64, err := parser.DecodeBase64(string(data))
+				base64, err := utils.DecodeBase64(string(data), true)
 				if err != nil {
 					logger.Logger.Debug(
 						"parse subscription failed", zap.String("url", query.Subs[i]),
@@ -169,7 +170,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 					)
 					return nil, NewSubscriptionParseError(err)
 				}
-				p, err := parser.ParseProxies(strings.Split(base64, "\n")...)
+				p, err := parser.ParseProxies(parser.ParseConfig{UseUDP: query.UseUDP}, strings.Split(base64, "\n")...)
 				if err != nil {
 					return nil, err
 				}
@@ -186,8 +187,8 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 		proxyList = append(proxyList, newProxies...)
 	}

-	if len(query.Proxy) != 0 {
-		p, err := parser.ParseProxies(query.Proxies...)
+	if len(query.Proxies) != 0 {
+		p, err := parser.ParseProxies(parser.ParseConfig{UseUDP: query.UseUDP}, query.Proxies...)
 		if err != nil {
 			return nil, err
 		}
@@ -200,6 +201,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 		}
 	}

+	// 去重
 	proxies := make(map[string]*P.Proxy)
 	newProxies := make([]P.Proxy, 0, len(proxyList))
 	for i := range proxyList {
@@ -216,6 +218,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 	}
 	proxyList = newProxies

+	// 移除
 	if strings.TrimSpace(query.Remove) != "" {
 		newProxyList := make([]P.Proxy, 0, len(proxyList))
 		for i := range proxyList {
@@ -233,29 +236,25 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 		proxyList = newProxyList
 	}

-	if len(query.ReplaceKeys) != 0 {
-
-		replaceRegs := make([]*regexp.Regexp, 0, len(query.ReplaceKeys))
-		for _, v := range query.ReplaceKeys {
-			replaceReg, err := regexp.Compile(v)
+	// 替换
+	if len(query.Replace) != 0 {
+		for k, v := range query.Replace {
+			replaceReg, err := regexp.Compile(k)
 			if err != nil {
 				logger.Logger.Debug("replace regexp compile failed", zap.Error(err))
 				return nil, NewRegexInvalidError("replace", err)
 			}
-			replaceRegs = append(replaceRegs, replaceReg)
-		}
 			for i := range proxyList {
-
-			for j, v := range replaceRegs {
-				if v.MatchString(proxyList[i].Name) {
-					proxyList[i].Name = v.ReplaceAllString(
-						proxyList[i].Name, query.ReplaceTo[j],
+				if replaceReg.MatchString(proxyList[i].Name) {
+					proxyList[i].Name = replaceReg.ReplaceAllString(
+						proxyList[i].Name, v,
 					)
 				}
 			}
 		}
 	}

+	// 重命名有相同名称的节点
 	names := make(map[string]int)
 	for i := range proxyList {
 		if _, exist := names[proxyList[i].Name]; exist {
@@ -273,6 +272,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 	var t = &model.Subscription{}
 	AddProxy(t, query.AutoTest, query.Lazy, clashType, proxyList...)

+	// 排序
 	switch query.Sort {
 	case "sizeasc":
 		sort.Sort(model.ProxyGroupsSortBySize(t.ProxyGroup))
--- a/model/clash.go
+++ b/model/clash.go
@@ -13,11 +13,12 @@ func GetSupportProxyTypes(clashType ClashType) map[string]bool {
 	supportProxyTypes := make(map[string]bool)

 	for _, parser := range parser.GetAllParsers() {
-		if clashType == Clash {
+		switch clashType {
+		case Clash:
 			if parser.SupportClash() {
 				supportProxyTypes[parser.GetType()] = true
 			}
-		} else if clashType == ClashMeta {
+		case ClashMeta:
 			if parser.SupportMeta() {
 				supportProxyTypes[parser.GetType()] = true
 			}
--- a/model/convert_config.go
+++ b/model/convert_config.go
@@ -0,0 +1,92 @@
+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"net/url"
+	"strings"
+
+	"github.com/bestnite/sub2clash/utils"
+	"github.com/gin-gonic/gin"
+)
+
+type ConvertConfig struct {
+	ClashType           ClashType            `json:"clashType" binding:"required"`
+	Subs                []string             `json:"subscriptions" binding:""`
+	Proxies             []string             `json:"proxies" binding:""`
+	Refresh             bool                 `json:"refresh" binding:""`
+	Template            string               `json:"template" binding:""`
+	RuleProviders       []RuleProviderStruct `json:"ruleProviders" binding:""`
+	Rules               []RuleStruct         `json:"rules" binding:""`
+	AutoTest            bool                 `json:"autoTest" binding:""`
+	Lazy                bool                 `json:"lazy" binding:""`
+	Sort                string               `json:"sort" binding:""`
+	Remove              string               `json:"remove" binding:""`
+	Replace             map[string]string    `json:"replace" binding:""`
+	NodeListMode        bool                 `json:"nodeList" binding:""`
+	IgnoreCountryGrooup bool                 `json:"ignoreCountryGroup" binding:""`
+	UserAgent           string               `json:"userAgent" binding:""`
+	UseUDP              bool                 `json:"useUDP" binding:""`
+}
+
+type RuleProviderStruct struct {
+	Behavior string `json:"behavior" binding:""`
+	Url      string `json:"url" binding:""`
+	Group    string `json:"group" binding:""`
+	Prepend  bool   `json:"prepend" binding:""`
+	Name     string `json:"name" binding:""`
+}
+
+type RuleStruct struct {
+	Rule    string `json:"rule" binding:""`
+	Prepend bool   `json:"prepend" binding:""`
+}
+
+func ParseConvertQuery(c *gin.Context) (ConvertConfig, error) {
+	config := c.Param("config")
+	queryBytes, err := utils.DecodeBase64(config, true)
+	if err != nil {
+		return ConvertConfig{}, errors.New("参数错误: " + err.Error())
+	}
+	var query ConvertConfig
+	err = json.Unmarshal([]byte(queryBytes), &query)
+	if err != nil {
+		return ConvertConfig{}, errors.New("参数错误: " + err.Error())
+	}
+	if len(query.Subs) == 0 && len(query.Proxies) == 0 {
+		return ConvertConfig{}, errors.New("参数错误: sub 和 proxy 不能同时为空")
+	}
+	if len(query.Subs) > 0 {
+		for i := range query.Subs {
+			if !strings.HasPrefix(query.Subs[i], "http") {
+				return ConvertConfig{}, errors.New("参数错误: sub 格式错误")
+			}
+			if _, err := url.ParseRequestURI(query.Subs[i]); err != nil {
+				return ConvertConfig{}, errors.New("参数错误: " + err.Error())
+			}
+		}
+	} else {
+		query.Subs = nil
+	}
+	if query.Template != "" {
+		if strings.HasPrefix(query.Template, "http") {
+			uri, err := url.ParseRequestURI(query.Template)
+			if err != nil {
+				return ConvertConfig{}, err
+			}
+			query.Template = uri.String()
+		}
+	}
+	if len(query.RuleProviders) > 0 {
+		names := make(map[string]bool)
+		for _, ruleProvider := range query.RuleProviders {
+			if _, ok := names[ruleProvider.Name]; ok {
+				return ConvertConfig{}, errors.New("参数错误: Rule-Provider 名称重复")
+			}
+			names[ruleProvider.Name] = true
+		}
+	} else {
+		query.RuleProviders = nil
+	}
+	return query, nil
+}
--- a/model/proxy/proxy.go
+++ b/model/proxy/proxy.go
@@ -1,6 +1,10 @@
 package proxy

-import "fmt"
+import (
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)

 type HTTPOptions struct {
 	Method  string              `yaml:"method,omitempty"`
@@ -144,7 +148,137 @@ func (p Proxy) MarshalYAML() (any, error) {
 			Name:  p.Name,
 			Vmess: p.Vmess,
 		}, nil
+	case "socks5":
+		return struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Socks `yaml:",inline"`
+		}{
+			Type:  p.Type,
+			Name:  p.Name,
+			Socks: p.Socks,
+		}, nil
 	default:
 		return nil, fmt.Errorf("unsupported proxy type: %s", p.Type)
 	}
 }
+
+func (p *Proxy) UnmarshalYAML(node *yaml.Node) error {
+	var temp struct {
+		Type string `yaml:"type"`
+		Name string `yaml:"name"`
+	}
+
+	if err := node.Decode(&temp); err != nil {
+		return err
+	}
+
+	p.Type = temp.Type
+	p.Name = temp.Name
+
+	switch temp.Type {
+	case "anytls":
+		var data struct {
+			Type   string `yaml:"type"`
+			Name   string `yaml:"name"`
+			Anytls `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Anytls = data.Anytls
+
+	case "hysteria":
+		var data struct {
+			Type     string `yaml:"type"`
+			Name     string `yaml:"name"`
+			Hysteria `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Hysteria = data.Hysteria
+
+	case "hysteria2":
+		var data struct {
+			Type      string `yaml:"type"`
+			Name      string `yaml:"name"`
+			Hysteria2 `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Hysteria2 = data.Hysteria2
+
+	case "ss":
+		var data struct {
+			Type        string `yaml:"type"`
+			Name        string `yaml:"name"`
+			ShadowSocks `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.ShadowSocks = data.ShadowSocks
+
+	case "ssr":
+		var data struct {
+			Type         string `yaml:"type"`
+			Name         string `yaml:"name"`
+			ShadowSocksR `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.ShadowSocksR = data.ShadowSocksR
+
+	case "trojan":
+		var data struct {
+			Type   string `yaml:"type"`
+			Name   string `yaml:"name"`
+			Trojan `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Trojan = data.Trojan
+
+	case "vless":
+		var data struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Vless `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Vless = data.Vless
+
+	case "vmess":
+		var data struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Vmess `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Vmess = data.Vmess
+
+	case "socks5":
+		var data struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Socks `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Socks = data.Socks
+
+	default:
+		return fmt.Errorf("unsupported proxy type: %s", temp.Type)
+	}
+
+	return nil
+}
--- a/model/sub_config.go
+++ b/model/sub_config.go
@@ -1,158 +0,0 @@
-package model
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"net/url"
-	"regexp"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-type SubConfig struct {
-	Sub                 string               `form:"sub" binding:""`
-	Subs                []string             `form:"-" binding:""`
-	Proxy               string               `form:"proxy" binding:""`
-	Proxies             []string             `form:"-" binding:""`
-	Refresh             bool                 `form:"refresh,default=false" binding:""`
-	Template            string               `form:"template" binding:""`
-	RuleProvider        string               `form:"ruleProvider" binding:""`
-	RuleProviders       []RuleProviderStruct `form:"-" binding:""`
-	Rule                string               `form:"rule" binding:""`
-	Rules               []RuleStruct         `form:"-" binding:""`
-	AutoTest            bool                 `form:"autoTest,default=false" binding:""`
-	Lazy                bool                 `form:"lazy,default=false" binding:""`
-	Sort                string               `form:"sort" binding:""`
-	Remove              string               `form:"remove" binding:""`
-	Replace             string               `form:"replace" binding:""`
-	ReplaceKeys         []string             `form:"-" binding:""`
-	ReplaceTo           []string             `form:"-" binding:""`
-	NodeListMode        bool                 `form:"nodeList,default=false" binding:""`
-	IgnoreCountryGrooup bool                 `form:"ignoreCountryGroup,default=false" binding:""`
-	UserAgent           string               `form:"userAgent" binding:""`
-}
-
-type RuleProviderStruct struct {
-	Behavior string
-	Url      string
-	Group    string
-	Prepend  bool
-	Name     string
-}
-
-type RuleStruct struct {
-	Rule    string
-	Prepend bool
-}
-
-func ParseSubQuery(c *gin.Context) (SubConfig, error) {
-	var query SubConfig
-	if err := c.ShouldBind(&query); err != nil {
-		return SubConfig{}, errors.New("参数错误: " + err.Error())
-	}
-	if query.Sub == "" && query.Proxy == "" {
-		return SubConfig{}, errors.New("参数错误: sub 和 proxy 不能同时为空")
-	}
-	if query.Sub != "" {
-		query.Subs = strings.Split(query.Sub, ",")
-		for i := range query.Subs {
-			if !strings.HasPrefix(query.Subs[i], "http") {
-				return SubConfig{}, errors.New("参数错误: sub 格式错误")
-			}
-			if _, err := url.ParseRequestURI(query.Subs[i]); err != nil {
-				return SubConfig{}, errors.New("参数错误: " + err.Error())
-			}
-		}
-	} else {
-		query.Subs = nil
-	}
-	if query.Proxy != "" {
-		query.Proxies = strings.Split(query.Proxy, ",")
-	} else {
-		query.Proxies = nil
-	}
-	if query.Template != "" {
-		if strings.HasPrefix(query.Template, "http") {
-			uri, err := url.ParseRequestURI(query.Template)
-			if err != nil {
-				return SubConfig{}, err
-			}
-			query.Template = uri.String()
-		}
-	}
-	if query.RuleProvider != "" {
-		reg := regexp.MustCompile(`\[(.*?)\]`)
-		ruleProviders := reg.FindAllStringSubmatch(query.RuleProvider, -1)
-		for i := range ruleProviders {
-			length := len(ruleProviders)
-			parts := strings.Split(ruleProviders[length-i-1][1], ",")
-			if len(parts) < 4 {
-				return SubConfig{}, errors.New("参数错误: ruleProvider 格式错误")
-			}
-			u := parts[1]
-			uri, err := url.ParseRequestURI(u)
-			if err != nil {
-				return SubConfig{}, errors.New("参数错误: " + err.Error())
-			}
-			u = uri.String()
-			if len(parts) == 4 {
-				hash := sha256.Sum224([]byte(u))
-				parts = append(parts, hex.EncodeToString(hash[:]))
-			}
-			query.RuleProviders = append(
-				query.RuleProviders, RuleProviderStruct{
-					Behavior: parts[0],
-					Url:      u,
-					Group:    parts[2],
-					Prepend:  parts[3] == "true",
-					Name:     parts[4],
-				},
-			)
-		}
-
-		names := make(map[string]bool)
-		for _, ruleProvider := range query.RuleProviders {
-			if _, ok := names[ruleProvider.Name]; ok {
-				return SubConfig{}, errors.New("参数错误: Rule-Provider 名称重复")
-			}
-			names[ruleProvider.Name] = true
-		}
-	} else {
-		query.RuleProviders = nil
-	}
-	if query.Rule != "" {
-		reg := regexp.MustCompile(`\[(.*?)\]`)
-		rules := reg.FindAllStringSubmatch(query.Rule, -1)
-		for i := range rules {
-			length := len(rules)
-			r := rules[length-1-i][1]
-			strings.LastIndex(r, ",")
-			parts := [2]string{}
-			parts[0] = r[:strings.LastIndex(r, ",")]
-			parts[1] = r[strings.LastIndex(r, ",")+1:]
-			query.Rules = append(
-				query.Rules, RuleStruct{
-					Rule:    parts[0],
-					Prepend: parts[1] == "true",
-				},
-			)
-		}
-	} else {
-		query.Rules = nil
-	}
-	if strings.TrimSpace(query.Replace) != "" {
-		reg := regexp.MustCompile(`\[<(.*?)>,<(.*?)>\]`)
-		replaces := reg.FindAllStringSubmatch(query.Replace, -1)
-		for i := range replaces {
-			length := len(replaces[i])
-			if length != 3 {
-				return SubConfig{}, errors.New("参数错误: replace 格式错误")
-			}
-			query.ReplaceKeys = append(query.ReplaceKeys, replaces[i][1])
-			query.ReplaceTo = append(query.ReplaceTo, replaces[i][2])
-		}
-	}
-	return query, nil
-}
--- a/parser/anytls.go
+++ b/parser/anytls.go
@@ -26,7 +26,7 @@ func (p *AnytlsParser) GetType() string {
 	return "anytls"
 }

-func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
+func (p *AnytlsParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -72,6 +72,7 @@ func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
 			Password:       password,
 			SNI:            sni,
 			SkipCertVerify: insecureBool,
+			UDP:            config.UseUDP,
 		},
 	}
 	return result, nil
--- a/parser/common.go
+++ b/parser/common.go
@@ -1,13 +1,13 @@
 package parser

 import (
-	"encoding/base64"
 	"errors"
 	"strconv"
 	"strings"
 	"unicode/utf8"

 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )

 func hasPrefix(proxy string, prefixes []string) bool {
@@ -49,7 +49,7 @@ func isLikelyBase64(s string) bool {
 		}
 	}

-	decoded, err := DecodeBase64(s)
+	decoded, err := utils.DecodeBase64(s, true)
 	if err != nil {
 		return false
 	}
@@ -60,31 +60,18 @@ func isLikelyBase64(s string) bool {
 	return true
 }

-func DecodeBase64(s string) (string, error) {
-	s = strings.TrimSpace(s)
-
-	if strings.Contains(s, "-") || strings.Contains(s, "_") {
-		s = strings.ReplaceAll(s, "-", "+")
-		s = strings.ReplaceAll(s, "_", "/")
-	}
-	if len(s)%4 != 0 {
-		s += strings.Repeat("=", 4-len(s)%4)
-	}
-	decodeStr, err := base64.StdEncoding.DecodeString(s)
-	if err != nil {
-		return "", err
-	}
-	return string(decodeStr), nil
+type ParseConfig struct {
+	UseUDP bool
 }

-func ParseProxies(proxies ...string) ([]P.Proxy, error) {
+func ParseProxies(config ParseConfig, proxies ...string) ([]P.Proxy, error) {
 	var result []P.Proxy
 	for _, proxy := range proxies {
 		if proxy != "" {
 			var proxyItem P.Proxy
 			var err error

-			proxyItem, err = ParseProxyWithRegistry(proxy)
+			proxyItem, err = ParseProxyWithRegistry(config, proxy)
 			if err != nil {
 				return nil, err
 			}
--- a/parser/hysteria.go
+++ b/parser/hysteria.go
@@ -27,7 +27,7 @@ func (p *HysteriaParser) GetType() string {
 	return "hysteria"
 }

-func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
+func (p *HysteriaParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
--- a/parser/hysteria2.go
+++ b/parser/hysteria2.go
@@ -26,7 +26,7 @@ func (p *Hysteria2Parser) GetType() string {
 	return "hysteria2"
 }

-func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
+func (p *Hysteria2Parser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
--- a/parser/registry.go
+++ b/parser/registry.go
@@ -9,7 +9,7 @@ import (
 )

 type ProxyParser interface {
-	Parse(proxy string) (P.Proxy, error)
+	Parse(config ParseConfig, proxy string) (P.Proxy, error)
 	GetPrefixes() []string
 	GetType() string
 	SupportClash() bool
@@ -64,7 +64,7 @@ func GetAllPrefixes() []string {
 	return prefixes
 }

-func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
+func ParseProxyWithRegistry(config ParseConfig, proxy string) (P.Proxy, error) {
 	proxy = strings.TrimSpace(proxy)
 	if proxy == "" {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "empty proxy string")
@@ -72,7 +72,7 @@ func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {

 	for prefix, parser := range registry.parsers {
 		if strings.HasPrefix(proxy, prefix) {
-			return parser.Parse(proxy)
+			return parser.Parse(config, proxy)
 		}
 	}

--- a/parser/shadowsocks.go
+++ b/parser/shadowsocks.go
@@ -6,6 +6,7 @@ import (
 	"strings"

 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )

 // ShadowsocksParser Shadowsocks协议解析器
@@ -30,7 +31,7 @@ func (p *ShadowsocksParser) GetType() string {
 }

 // Parse 解析Shadowsocks代理
-func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
+func (p *ShadowsocksParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -43,7 +44,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 				break
 			}
 		}
-		d, err := DecodeBase64(s[0])
+		d, err := utils.DecodeBase64(s[0], true)
 		if err != nil {
 			return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
 		}
@@ -76,7 +77,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 	password, hasPassword := link.User.Password()

 	if !hasPassword && isLikelyBase64(method) {
-		decodedStr, err := DecodeBase64(method)
+		decodedStr, err := utils.DecodeBase64(method, true)
 		if err == nil {
 			methodAndPass := strings.SplitN(decodedStr, ":", 2)
 			if len(methodAndPass) == 2 {
@@ -88,7 +89,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 		}
 	}
 	if password != "" && isLikelyBase64(password) {
-		password, err = DecodeBase64(password)
+		password, err = utils.DecodeBase64(password, true)
 		if err != nil {
 			return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
 		}
@@ -108,9 +109,9 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 			Password: password,
 			Server:   server,
 			Port:     port,
+			UDP:      config.UseUDP,
 		},
 	}
-
 	return result, nil
 }

--- a/parser/shadowsocksr.go
+++ b/parser/shadowsocksr.go
@@ -7,6 +7,7 @@ import (
 	"strings"

 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )

 type ShadowsocksRParser struct{}
@@ -27,7 +28,7 @@ func (p *ShadowsocksRParser) GetType() string {
 	return "ssr"
 }

-func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
+func (p *ShadowsocksRParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -39,7 +40,7 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 		}
 	}

-	proxy, err := DecodeBase64(proxy)
+	proxy, err := utils.DecodeBase64(proxy, true)
 	if err != nil {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidBase64, err.Error())
 	}
@@ -55,7 +56,7 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 	protocol := parts[2]
 	method := parts[3]
 	obfs := parts[4]
-	password, err := DecodeBase64(parts[5])
+	password, err := utils.DecodeBase64(parts[5], true)
 	if err != nil {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
 	}
@@ -73,13 +74,13 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 			return P.Proxy{}, fmt.Errorf("%w: %s", ErrCannotParseParams, err.Error())
 		}
 		if params.Get("obfsparam") != "" {
-			obfsParam, err = DecodeBase64(params.Get("obfsparam"))
+			obfsParam, err = utils.DecodeBase64(params.Get("obfsparam"), true)
 		}
 		if params.Get("protoparam") != "" {
-			protoParam, err = DecodeBase64(params.Get("protoparam"))
+			protoParam, err = utils.DecodeBase64(params.Get("protoparam"), true)
 		}
 		if params.Get("remarks") != "" {
-			remarks, err = DecodeBase64(params.Get("remarks"))
+			remarks, err = utils.DecodeBase64(params.Get("remarks"), true)
 		} else {
 			remarks = server + ":" + strconv.Itoa(port)
 		}
@@ -100,9 +101,9 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 			Password:      password,
 			ObfsParam:     obfsParam,
 			ProtocolParam: protoParam,
+			UDP:           config.UseUDP,
 		},
 	}
-
 	return result, nil
 }

--- a/parser/socks.go
+++ b/parser/socks.go
@@ -6,6 +6,7 @@ import (
 	"strings"

 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )

 type SocksParser struct{}
@@ -18,14 +19,14 @@ func (p *SocksParser) SupportMeta() bool {
 }

 func (p *SocksParser) GetPrefixes() []string {
-	return []string{"socks://"}
+	return []string{"socks://", "socks5://"}
 }

 func (p *SocksParser) GetType() string {
 	return "socks5"
 }

-func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
+func (p *SocksParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -59,7 +60,7 @@ func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
 	password, hasPassword := link.User.Password()

 	if !hasPassword && isLikelyBase64(username) {
-		decodedStr, err := DecodeBase64(username)
+		decodedStr, err := utils.DecodeBase64(username, true)
 		if err == nil {
 			usernameAndPassword := strings.SplitN(decodedStr, ":", 2)
 			if len(usernameAndPassword) == 2 {
--- a/parser/trojan.go
+++ b/parser/trojan.go
@@ -26,7 +26,7 @@ func (p *TrojanParser) GetType() string {
 	return "trojan"
 }

-func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
+func (p *TrojanParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -58,7 +58,17 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
 	remarks = strings.TrimSpace(remarks)

 	query := link.Query()
-	network, security, alpnStr, sni, pbk, sid, fp, path, host, serviceName, udp := query.Get("type"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("pbk"), query.Get("sid"), query.Get("fp"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("udp")
+	network, security, alpnStr, sni, pbk, sid, fp, path, host, serviceName, udp, insecure := query.Get("type"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("pbk"), query.Get("sid"), query.Get("fp"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("udp"), query.Get("allowInsecure")
+
+	insecureBool := insecure == "1"
+	result := P.Trojan{
+		Server:         server,
+		Port:           port,
+		Password:       password,
+		Network:        network,
+		UDP:            udp == "true",
+		SkipCertVerify: insecureBool,
+	}

 	var alpn []string
 	if strings.Contains(alpnStr, ",") {
@@ -66,27 +76,23 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
 	} else {
 		alpn = nil
 	}
-
-	result := P.Trojan{
-		Server:   server,
-		Port:     port,
-		Password: password,
-		Network:  network,
-		UDP:      udp == "true",
+	if len(alpn) > 0 {
+		result.ALPN = alpn
 	}

-	if security == "xtls" || security == "tls" {
-		result.ALPN = alpn
+	if fp != "" {
+		result.ClientFingerprint = fp
+	}
+
+	if sni != "" {
 		result.SNI = sni
 	}

 	if security == "reality" {
-		result.SNI = sni
 		result.RealityOpts = P.RealityOptions{
 			PublicKey: pbk,
 			ShortID:   sid,
 		}
-		result.Fingerprint = fp
 	}

 	if network == "ws" {
--- a/parser/vless.go
+++ b/parser/vless.go
@@ -26,7 +26,7 @@ func (p *VlessParser) GetType() string {
 	return "vless"
 }

-func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
+func (p *VlessParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -57,6 +57,7 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
 	} else {
 		alpn = nil
 	}
+
 	remarks := link.Fragment
 	if remarks == "" {
 		remarks = fmt.Sprintf("%s:%s", server, portStr)
@@ -69,24 +70,31 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
 		UUID:           uuid,
 		Flow:           flow,
 		UDP:            udp == "true",
+		SkipCertVerify: insecureBool,
+	}
+
+	if len(alpn) > 0 {
+		result.ALPN = alpn
+	}
+
+	if fp != "" {
+		result.ClientFingerprint = fp
+	}
+
+	if sni != "" {
+		result.ServerName = sni
 	}

 	if security == "tls" {
 		result.TLS = true
-		result.ALPN = alpn
-		result.SkipCertVerify = insecureBool
-		result.Fingerprint = fp
-		result.ServerName = sni
 	}

 	if security == "reality" {
 		result.TLS = true
-		result.ServerName = sni
 		result.RealityOpts = P.RealityOptions{
 			PublicKey: pbk,
 			ShortID:   sid,
 		}
-		result.Fingerprint = fp
 	}

 	if _type == "ws" {
--- a/parser/vmess.go
+++ b/parser/vmess.go
@@ -8,6 +8,7 @@ import (
 	"strings"

 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )

 type VmessJson struct {
@@ -46,7 +47,7 @@ func (p *VmessParser) GetType() string {
 	return "vmess"
 }

-func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
+func (p *VmessParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -57,7 +58,7 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
 			break
 		}
 	}
-	base64, err := DecodeBase64(proxy)
+	base64, err := utils.DecodeBase64(proxy, true)
 	if err != nil {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidBase64, err.Error())
 	}
@@ -99,27 +100,38 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
 		name = vmess.Ps
 	}

-	result := P.Vmess{
-		Server:  vmess.Add,
-		Port:    port,
-		UUID:    vmess.Id,
-		AlterID: aid,
-		Cipher:  vmess.Scy,
-	}
-
-	if vmess.Tls == "tls" {
 	var alpn []string
 	if strings.Contains(vmess.Alpn, ",") {
 		alpn = strings.Split(vmess.Alpn, ",")
 	} else {
 		alpn = nil
 	}
-		result.TLS = true
-		result.Fingerprint = vmess.Fp
+
+	result := P.Vmess{
+		Server:  vmess.Add,
+		Port:    port,
+		UUID:    vmess.Id,
+		AlterID: aid,
+		Cipher:  vmess.Scy,
+		UDP:     config.UseUDP,
+	}
+
+	if len(alpn) > 0 {
 		result.ALPN = alpn
+	}
+
+	if vmess.Fp != "" {
+		result.ClientFingerprint = vmess.Fp
+	}
+
+	if vmess.Sni != "" {
 		result.ServerName = vmess.Sni
 	}

+	if vmess.Tls == "tls" {
+		result.TLS = true
+	}
+
 	if vmess.Net == "ws" {
 		if vmess.Path == "" {
 			vmess.Path = "/"
--- a/server/handler/convert.go
+++ b/server/handler/convert.go
@@ -12,14 +12,14 @@ import (
 	"gopkg.in/yaml.v3"
 )

-func SubHandler(model M.ClashType, template string) func(c *gin.Context) {
+func ConvertHandler(template string) func(c *gin.Context) {
 	return func(c *gin.Context) {
-		query, err := M.ParseSubQuery(c)
+		query, err := M.ParseConvertQuery(c)
 		if err != nil {
 			c.String(http.StatusBadRequest, err.Error())
 			return
 		}
-		sub, err := common.BuildSub(model, query, template, config.GlobalConfig.CacheExpire, config.GlobalConfig.RequestRetryTimes)
+		sub, err := common.BuildSub(query.ClashType, query, template, config.GlobalConfig.CacheExpire, config.GlobalConfig.RequestRetryTimes)
 		if err != nil {
 			c.String(http.StatusInternalServerError, err.Error())
 			return
--- a/server/handler/short_link.go
+++ b/server/handler/short_link.go
@@ -1,6 +1,7 @@
 package handler

 import (
+	"fmt"
 	"io"
 	"net/http"
 	"strings"
@@ -141,7 +142,6 @@ func UpdateLinkHandler(c *gin.Context) {
 }

 func GetRawConfHandler(c *gin.Context) {
-
 	hash := c.Param("hash")
 	password := c.Query("password")

@@ -168,7 +168,19 @@ func GetRawConfHandler(c *gin.Context) {
 		return
 	}

-	response, err := http.Get(strings.TrimSuffix(config.GlobalConfig.Address, "/") + "/" + shortLink.Url)
+	scheme := "http"
+	if c.Request.TLS != nil {
+		scheme = "https"
+	}
+	host := c.Request.Host
+	targetPath := strings.TrimPrefix(shortLink.Url, "/")
+	requestURL := fmt.Sprintf("%s://%s/%s", scheme, host, targetPath)
+
+	client := &http.Client{
+		Timeout: 30 * time.Second, // 30秒超时
+	}
+
+	response, err := client.Get(requestURL)
 	if err != nil {
 		respondWithError(c, http.StatusInternalServerError, "请求错误: "+err.Error())
 		return
@@ -185,7 +197,6 @@ func GetRawConfHandler(c *gin.Context) {
 }

 func GetRawConfUriHandler(c *gin.Context) {
-
 	hash := c.Query("hash")
 	password := c.Query("password")

--- a/server/route.go
+++ b/server/route.go
@@ -8,7 +8,6 @@ import (

 	"github.com/bestnite/sub2clash/config"
 	"github.com/bestnite/sub2clash/constant"
-	"github.com/bestnite/sub2clash/model"
 	"github.com/bestnite/sub2clash/server/handler"
 	"github.com/bestnite/sub2clash/server/middleware"

@@ -40,8 +39,7 @@ func SetRoute(r *gin.Engine) {
 			)
 		},
 	)
-	r.GET("/clash", middleware.ZapLogger(), handler.SubHandler(model.Clash, config.GlobalConfig.ClashTemplate))
-	r.GET("/meta", middleware.ZapLogger(), handler.SubHandler(model.ClashMeta, config.GlobalConfig.MetaTemplate))
+	r.GET("/convert/:config", middleware.ZapLogger(), handler.ConvertHandler(config.GlobalConfig.ClashTemplate))
 	r.GET("/s/:hash", middleware.ZapLogger(), handler.GetRawConfHandler)
 	r.POST("/short", middleware.ZapLogger(), handler.GenerateLinkHandler)
 	r.PUT("/short", middleware.ZapLogger(), handler.UpdateLinkHandler)
--- a/server/static/index.html
+++ b/server/static/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="zh-CN">
+<html lang="zh-CN" data-bs-theme="light">

 <head>
    <meta charset="UTF-8" />
@@ -28,10 +28,38 @@
            height: 25px;
            width: 25px;
        }
+
+        /* 主题切换按钮样式 */
+        .theme-toggle {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            z-index: 1000;
+            border: none;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            font-size: 20px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: all 0.3s ease;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+
+        .theme-toggle:hover {
+            transform: scale(1.1);
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+        }
    </style>
 </head>

-<body class="bg-light">
+<body>
+    <!-- 主题切换按钮 -->
+    <button class="theme-toggle btn btn-outline-secondary" onclick="toggleTheme()" title="切换深色/浅色模式">
+        <span id="theme-icon">🌙</span>
+    </button>
+
    <div class="container mt-5">
        <div class="mb-4">
            <h2>sub2clash</h2>
@@ -54,8 +82,8 @@
        <div class="form-group mb-3">
            <label for="endpoint">客户端类型:</label>
            <select class="form-control" id="endpoint" name="endpoint">
-                <option value="clash">Clash</option>
-                <option value="meta" selected>Clash.Meta</option>
+                <option value="1">Clash</option>
+                <option value="2" selected>Clash.Meta</option>
            </select>
        </div>
        <!-- Template -->
@@ -104,6 +132,11 @@
            <input class="form-check-input" id="igcg" name="igcg" type="checkbox" />
            <label class="form-check-label" for="igcg">不输出国家策略组</label>
        </div>
+        <!-- Use UDP -->
+        <div class="form-check mb-3">
+            <input class="form-check-input" id="useUDP" name="useUDP" type="checkbox" />
+            <label class="form-check-label" for="useUDP">使用 UDP</label>
+        </div>
        <!-- Rule Provider -->
        <div class="form-group mb-3" id="ruleProviderGroup">
            <label>Rule Provider:</label>
@@ -145,8 +178,9 @@
        <div class="form-group mb-5">
            <label for="apiLink">配置链接:</label>
            <div class="input-group mb-2">
-                <input class="form-control bg-light" id="apiLink" type="text" placeholder="链接" readonly
+                <input class="form-control" id="apiLink" type="text" placeholder="链接" readonly
                    style="cursor: not-allowed;" />
+                <button class="btn btn-primary" onclick="generateURL()" type="button">生成配置</button>
                <button class="btn btn-primary" onclick="copyToClipboard('apiLink',this)" type="button">
                    复制链接
                </button>
@@ -162,7 +196,7 @@
                </button>
            </div>
            <div class="input-group">
-                <input class="form-control bg-light" id="apiShortLink" type="text" placeholder="短链接" readonly
+                <input class="form-control" id="apiShortLink" type="text" placeholder="短链接" readonly
                    style="cursor: not-allowed;" />
                <button class="btn btn-primary" onclick="updateShortLink()" type="button">
                    更新短链
--- a/server/static/index.js
+++ b/server/static/index.js
@@ -1,11 +1,9 @@
 function setInputReadOnly(input, readonly) {
  if (readonly) {
    input.readOnly = true;
-    input.classList.add('bg-light');
    input.style.cursor = 'not-allowed';
  } else {
    input.readOnly = false;
-    input.classList.remove('bg-light');
    input.style.cursor = 'auto';
  }
 }
@@ -19,6 +17,7 @@ function clearExistingValues() {
  document.getElementById("autoTest").checked = false;
  document.getElementById("lazy").checked = false;
  document.getElementById("igcg").checked = false;
+  document.getElementById("useUDP").checked = false;
  document.getElementById("template").value = "";
  document.getElementById("sort").value = "nameasc";
  document.getElementById("remove").value = "";
@@ -50,85 +49,57 @@ function clearExistingValues() {
 }

 function generateURI() {
-  const queryParams = [];
+  const config = {};

-  // 获取 API Endpoint
-  const endpoint = document.getElementById("endpoint").value;
+  config.clashType = parseInt(document.getElementById("endpoint").value);

-  // 获取并组合订阅链接
  let subLines = document
    .getElementById("sub")
    .value.split("\n")
    .filter((line) => line.trim() !== "");
-  let noSub = false;
-  // 去除 subLines 中空元素
-  subLines = subLines.map((item) => {
-    if (item !== "") {
-      return item;
-    }
-  });
  if (subLines.length > 0) {
-    queryParams.push(`sub=${encodeURIComponent(subLines.join(","))}`);
-  } else {
-    noSub = true;
+    config.subscriptions = subLines;
  }

-  // 获取并组合节点分享链接
  let proxyLines = document
    .getElementById("proxy")
    .value.split("\n")
    .filter((line) => line.trim() !== "");
-  let noProxy = false;
-  // 去除 proxyLines 中空元素
-  proxyLines = proxyLines.map((item) => {
-    if (item !== "") {
-      return item;
-    }
-  });
  if (proxyLines.length > 0) {
-    queryParams.push(`proxy=${encodeURIComponent(proxyLines.join(","))}`);
-  } else {
-    noProxy = true;
+    config.proxies = proxyLines;
  }
-  if (noSub && noProxy) {
-    // alert("订阅链接和节点分享链接不能同时为空！");
+
+  if (
+    (config.subscriptions === undefined || config.subscriptions.length === 0) &&
+    (config.proxies === undefined || config.proxies.length === 0)
+  ) {
    return "";
  }

-  // 获取订阅user-agent标识
-  const userAgent = document.getElementById("user-agent").value;
-  queryParams.push(`userAgent=${encodeURIComponent(userAgent)}`);
+  config.userAgent = document.getElementById("user-agent").value;

-  // 获取复选框的值
-  const refresh = document.getElementById("refresh").checked;
-  queryParams.push(`refresh=${refresh ? "true" : "false"}`);
-  const autoTest = document.getElementById("autoTest").checked;
-  queryParams.push(`autoTest=${autoTest ? "true" : "false"}`);
-  const lazy = document.getElementById("lazy").checked;
-  queryParams.push(`lazy=${lazy ? "true" : "false"}`);
-  const nodeList = document.getElementById("nodeList").checked;
-  queryParams.push(`nodeList=${nodeList ? "true" : "false"}`);
-  const igcg = document.getElementById("igcg").checked;
-  queryParams.push(`ignoreCountryGroup=${igcg ? "true" : "false"}`);
+  config.refresh = document.getElementById("refresh").checked;
+  config.autoTest = document.getElementById("autoTest").checked;
+  config.lazy = document.getElementById("lazy").checked;
+  config.nodeList = document.getElementById("nodeList").checked;
+  config.ignoreCountryGroup = document.getElementById("igcg").checked;
+  config.useUDP = document.getElementById("useUDP").checked;

-  // 获取模板链接或名称（如果存在）
  const template = document.getElementById("template").value;
  if (template.trim() !== "") {
-    queryParams.push(`template=${encodeURIComponent(template)}`);
+    config.template = template;
  }

-  // 获取Rule Provider和规则
-  const ruleProviders = document.getElementsByName("ruleProvider");
-  const rules = document.getElementsByName("rule");
-  let providers = [];
-  for (let i = 0; i < ruleProviders.length / 5; i++) {
+  const ruleProvidersElements = document.getElementsByName("ruleProvider");
+  if (ruleProvidersElements.length > 0) {
+    const ruleProviders = [];
+    for (let i = 0; i < ruleProvidersElements.length / 5; i++) {
      let baseIndex = i * 5;
-    let behavior = ruleProviders[baseIndex].value;
-    let url = ruleProviders[baseIndex + 1].value;
-    let group = ruleProviders[baseIndex + 2].value;
-    let prepend = ruleProviders[baseIndex + 3].value;
-    let name = ruleProviders[baseIndex + 4].value;
-    // 是否存在空值
+      let behavior = ruleProvidersElements[baseIndex].value;
+      let url = ruleProvidersElements[baseIndex + 1].value;
+      let group = ruleProvidersElements[baseIndex + 2].value;
+      let prepend = ruleProvidersElements[baseIndex + 3].value;
+      let name = ruleProvidersElements[baseIndex + 4].value;
      if (
        behavior.trim() === "" ||
        url.trim() === "" ||
@@ -136,53 +107,80 @@ function generateURI() {
        prepend.trim() === "" ||
        name.trim() === ""
      ) {
-      // alert("Rule Provider 中存在空值，请检查后重试！");
        return "";
      }
-    providers.push(`[${behavior},${url},${group},${prepend},${name}]`);
+      ruleProviders.push({
+        behavior: behavior,
+        url: url,
+        group: group,
+        prepend: prepend.toLowerCase() === "true",
+        name: name,
+      });
+    }
+    if (ruleProviders.length > 0) {
+      config.ruleProviders = ruleProviders;
+    }
  }
-  queryParams.push(`ruleProvider=${encodeURIComponent(providers.join(","))}`);

-  let ruleList = [];
-  for (let i = 0; i < rules.length / 2; i++) {
-    if (rules[i * 2].value.trim() !== "") {
-      let rule = rules[i * 2].value;
-      let prepend = rules[i * 2 + 1].value;
-      // 是否存在空值
+  const rulesElements = document.getElementsByName("rule");
+  if (rulesElements.length > 0) {
+    const rules = [];
+    for (let i = 0; i < rulesElements.length / 2; i++) {
+      if (rulesElements[i * 2].value.trim() !== "") {
+        let rule = rulesElements[i * 2].value;
+        let prepend = rulesElements[i * 2 + 1].value;
        if (rule.trim() === "" || prepend.trim() === "") {
-        // alert("Rule 中存在空值，请检查后重试！");
          return "";
        }
-      ruleList.push(`[${rule},${prepend}]`);
+        rules.push({
+          rule: rule,
+          prepend: prepend.toLowerCase() === "true",
+        });
+      }
+    }
+    if (rules.length > 0) {
+      config.rules = rules;
    }
  }
-  queryParams.push(`rule=${encodeURIComponent(ruleList.join(","))}`);

-  // 获取排序策略
-  const sort = document.getElementById("sort").value;
-  queryParams.push(`sort=${sort}`);
+  config.sort = document.getElementById("sort").value;

-  // 获取删除节点的正则表达式
  const remove = document.getElementById("remove").value;
  if (remove.trim() !== "") {
-    queryParams.push(`remove=${encodeURIComponent(remove)}`);
+    config.remove = remove;
  }

-  // 获取替换节点名称的正则表达式
-  let replaceList = [];
-  const replaces = document.getElementsByName("replace");
-  for (let i = 0; i < replaces.length / 2; i++) {
-    let replaceStr = `<${replaces[i * 2].value}>`;
-    let replaceTo = `<${replaces[i * 2 + 1].value}>`;
+  const replacesElements = document.getElementsByName("replace");
+  if (replacesElements.length > 0) {
+    const replace = {};
+    for (let i = 0; i < replacesElements.length / 2; i++) {
+      let replaceStr = replacesElements[i * 2].value;
+      let replaceTo = replacesElements[i * 2 + 1].value;
      if (replaceStr.trim() === "") {
-      // alert("重命名设置中存在空值，请检查后重试！");
        return "";
      }
-    replaceList.push(`[${replaceStr},${replaceTo}]`);
+      replace[replaceStr] = replaceTo;
+    }
+    if (Object.keys(replace).length > 0) {
+      config.replace = replace;
+    }
  }
-  queryParams.push(`replace=${encodeURIComponent(replaceList.join(","))}`);

-  return `${endpoint}?${queryParams.join("&")}`;
+  const jsonString = JSON.stringify(config);
+  // 解决 btoa 中文报错，使用 TextEncoder 进行 UTF-8 编码再 base64
+  function base64EncodeUnicode(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = '';
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  }
+  const encoded = base64EncodeUnicode(jsonString);
+  const urlSafeBase64 = encoded
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+
+  return `convert/${urlSafeBase64}`;
 }

 // 将输入框中的 URL 解析为参数
@@ -215,11 +213,11 @@ async function parseInputURL() {
    q.append("password", password);
    try {
      const response = await axios.get("./short?" + q.toString());
-      url = new URL(window.location.href + response.data);
+      url = new URL(response.data, window.location.href);

      // 回显配置链接
      const apiLinkInput = document.querySelector("#apiLink");
-      apiLinkInput.value = `${window.location.origin}${window.location.pathname}${response.data}`;
+      apiLinkInput.value = url.href;
      setInputReadOnly(apiLinkInput, true);

      // 回显短链相关信息
@@ -247,94 +245,106 @@ async function parseInputURL() {
      alert("获取短链失败，请检查密码！");
    }
  }
-  let params = new URLSearchParams(url.search);
-
-  // 分配值到对应的输入框
  const pathSections = url.pathname.split("/");
-  const lastSection = pathSections[pathSections.length - 1];
-  const clientTypeSelect = document.getElementById("endpoint");
-  switch (lastSection.toLowerCase()) {
-    case "meta":
-      clientTypeSelect.value = "meta";
-      break;
-    case "clash":
-    default:
-      clientTypeSelect.value = "clash";
-      break;
+  const convertIndex = pathSections.findIndex((s) => s === "convert");
+
+  if (convertIndex === -1 || convertIndex + 1 >= pathSections.length) {
+    alert("无效的配置链接，请确认链接为新版格式。");
+    return;
+  }
+  const base64Config = pathSections[convertIndex + 1];
+  let config;
+  try {
+    const regularBase64 = base64Config.replace(/-/g, "+").replace(/_/g, "/");
+    const decodedStr = atob(regularBase64);
+    config = JSON.parse(decodeURIComponent(escape(decodedStr)));
+  } catch (e) {
+    alert("解析配置失败！");
+    console.error(e);
+    return;
  }

-  if (params.has("sub")) {
-    document.getElementById("sub").value = decodeURIComponent(params.get("sub"))
-      .split(",")
-      .join("\n");
+  document.getElementById("endpoint").value = config.clashType || "1";
+
+  if (config.subscriptions) {
+    document.getElementById("sub").value = config.subscriptions.join("\n");
  }

-  if (params.has("proxy")) {
-    document.getElementById("proxy").value = decodeURIComponent(
-      params.get("proxy")
-    )
-      .split(",")
-      .join("\n");
+  if (config.proxies) {
+    document.getElementById("proxy").value = config.proxies.join("\n");
  }

-  if (params.has("refresh")) {
-    document.getElementById("refresh").checked =
-      params.get("refresh") === "true";
+  if (config.refresh) {
+    document.getElementById("refresh").checked = config.refresh;
  }

-  if (params.has("autoTest")) {
-    document.getElementById("autoTest").checked =
-      params.get("autoTest") === "true";
+  if (config.autoTest) {
+    document.getElementById("autoTest").checked = config.autoTest;
  }

-  if (params.has("lazy")) {
-    document.getElementById("lazy").checked = params.get("lazy") === "true";
+  if (config.lazy) {
+    document.getElementById("lazy").checked = config.lazy;
  }

-  if (params.has("template")) {
-    document.getElementById("template").value = decodeURIComponent(
-      params.get("template")
-    );
+  if (config.template) {
+    document.getElementById("template").value = config.template;
  }

-  if (params.has("sort")) {
-    document.getElementById("sort").value = params.get("sort");
+  if (config.sort) {
+    document.getElementById("sort").value = config.sort;
  }

-  if (params.has("remove")) {
-    document.getElementById("remove").value = decodeURIComponent(
-      params.get("remove")
-    );
+  if (config.remove) {
+    document.getElementById("remove").value = config.remove;
  }

-  if (params.has("userAgent")) {
-    document.getElementById("user-agent").value = decodeURIComponent(
-      params.get("userAgent")
-    );
+  if (config.userAgent) {
+    document.getElementById("user-agent").value = config.userAgent;
  }

-  if (params.has("ignoreCountryGroup")) {
-    document.getElementById("igcg").checked = 
-      params.get("ignoreCountryGroup") === "true";
+  if (config.ignoreCountryGroup) {
+    document.getElementById("igcg").checked = config.ignoreCountryGroup;
  }

-  if (params.has("replace")) {
-    parseAndFillReplaceParams(decodeURIComponent(params.get("replace")));
+  if (config.replace) {
+    const replaceGroup = document.getElementById("replaceGroup");
+    for (const original in config.replace) {
+      const div = createReplace();
+      div.children[0].value = original;
+      div.children[1].value = config.replace[original];
+      replaceGroup.appendChild(div);
+    }
  }

-  if (params.has("ruleProvider")) {
-    parseAndFillRuleProviderParams(
-      decodeURIComponent(params.get("ruleProvider"))
-    );
+  if (config.ruleProviders) {
+    const ruleProviderGroup = document.getElementById("ruleProviderGroup");
+    for (const p of config.ruleProviders) {
+      const div = createRuleProvider();
+      div.children[0].value = p.behavior;
+      div.children[1].value = p.url;
+      div.children[2].value = p.group;
+      div.children[3].value = p.prepend;
+      div.children[4].value = p.name;
+      ruleProviderGroup.appendChild(div);
+    }
  }

-  if (params.has("rule")) {
-    parseAndFillRuleParams(decodeURIComponent(params.get("rule")));
+  if (config.rules) {
+    const ruleGroup = document.getElementById("ruleGroup");
+    for (const r of config.rules) {
+      const div = createRule();
+      div.children[0].value = r.rule;
+      div.children[1].value = r.prepend;
+      ruleGroup.appendChild(div);
+    }
  }

-  if (params.has("nodeList")) {
-    document.getElementById("nodeList").checked =
-      params.get("nodeList") === "true";
+  if (config.nodeList) {
+    document.getElementById("nodeList").checked = config.nodeList;
+  }
+
+  if (config.useUDP) {
+    document.getElementById("useUDP").checked = config.useUDP;
  }
 }

@@ -346,51 +356,6 @@ function clearInputGroup(groupId) {
  }
 }

-function parseAndFillReplaceParams(replaceParams) {
-  const replaceGroup = document.getElementById("replaceGroup");
-  let matches;
-  const regex = /\[(<.*?>),(<.*?>)\]/g;
-  const str = decodeURIComponent(replaceParams);
-  while ((matches = regex.exec(str)) !== null) {
-    const div = createReplace();
-    const original = matches[1].slice(1, -1); // Remove < and >
-    const replacement = matches[2].slice(1, -1); // Remove < and >
-
-    div.children[0].value = original;
-    div.children[1].value = replacement;
-    replaceGroup.appendChild(div);
-  }
-}
-
-function parseAndFillRuleProviderParams(ruleProviderParams) {
-  const ruleProviderGroup = document.getElementById("ruleProviderGroup");
-  let matches;
-  const regex = /\[(.*?),(.*?),(.*?),(.*?),(.*?)\]/g;
-  const str = decodeURIComponent(ruleProviderParams);
-  while ((matches = regex.exec(str)) !== null) {
-    const div = createRuleProvider();
-    div.children[0].value = matches[1];
-    div.children[1].value = matches[2];
-    div.children[2].value = matches[3];
-    div.children[3].value = matches[4];
-    div.children[4].value = matches[5];
-    ruleProviderGroup.appendChild(div);
-  }
-}
-
-function parseAndFillRuleParams(ruleParams) {
-  const ruleGroup = document.getElementById("ruleGroup");
-  let matches;
-  const regex = /\[(.*?),(.*?)\]/g;
-  const str = decodeURIComponent(ruleParams);
-  while ((matches = regex.exec(str)) !== null) {
-    const div = createRule();
-    div.children[0].value = matches[1];
-    div.children[1].value = matches[2];
-    ruleGroup.appendChild(div);
-  }
-}
-
 async function copyToClipboard(elem, e) {
  const apiLinkInput = document.querySelector(`#${elem}`).value;
  try {
@@ -580,4 +545,53 @@ function updateShortLink() {
    });
 }

+
+// 主题切换功能
+function initTheme() {
+  const html = document.querySelector('html');
+  const themeIcon = document.getElementById('theme-icon');
+  let theme;
+
+  // 从localStorage获取用户偏好的主题
+  const savedTheme = localStorage.getItem('theme');
+
+  if (savedTheme) {
+    // 如果用户之前设置过主题，使用保存的主题
+    theme = savedTheme;
+  } else {
+    // 如果没有设置过，检测系统主题偏好
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    theme = prefersDark ? 'dark' : 'light';
+  }
+
+  // 设置主题
+  html.setAttribute('data-bs-theme', theme);
+
+  // 更新图标
+  if (theme === 'dark') {
+    themeIcon.textContent = '☀️';
+  } else {
+    themeIcon.textContent = '🌙';
+  }
+}
+
+function toggleTheme() {
+  const html = document.querySelector('html');
+  const currentTheme = html.getAttribute('data-bs-theme');
+  // 切换主题
+  const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+  html.setAttribute('data-bs-theme', newTheme);
+
+  // 更新图标
+  if (newTheme === 'dark') {
+    themeIcon.textContent = '☀️';
+  } else {
+    themeIcon.textContent = '🌙';
+  }
+
+  // 保存用户偏好到localStorage
+  localStorage.setItem('theme', newTheme);
+}
+
 listenInput();
+initTheme();
--- a/test/parser/anytls_test.go
+++ b/test/parser/anytls_test.go
@@ -22,7 +22,7 @@ func TestAnytls_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestAnytls_Basic_WithSNI(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -72,7 +72,7 @@ func TestAnytls_Basic_WithInsecure(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -96,7 +96,7 @@ func TestAnytls_Basic_IPv6Address(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -121,7 +121,7 @@ func TestAnytls_Basic_ComplexPassword(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -145,7 +145,7 @@ func TestAnytls_Basic_NoPassword(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -169,7 +169,7 @@ func TestAnytls_Basic_UsernameOnly(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -182,7 +182,7 @@ func TestAnytls_Error_MissingServer(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anytls://password123@:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -192,7 +192,7 @@ func TestAnytls_Error_MissingPort(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anytls://password123@127.0.0.1"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -202,7 +202,7 @@ func TestAnytls_Error_InvalidPort(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anytls://password123@127.0.0.1:99999"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -212,7 +212,7 @@ func TestAnytls_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anyssl://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/hysteria2_test.go
+++ b/test/parser/hysteria2_test.go
@@ -22,7 +22,7 @@ func TestHysteria2_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestHysteria2_Basic_AltPrefix(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -73,7 +73,7 @@ func TestHysteria2_Basic_WithObfs(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -97,7 +97,7 @@ func TestHysteria2_Basic_IPv6Address(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -124,7 +124,7 @@ func TestHysteria2_Basic_FullConfig(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -148,7 +148,7 @@ func TestHysteria2_Basic_NoPassword(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -161,7 +161,7 @@ func TestHysteria2_Error_MissingServer(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria2://password123@:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -171,7 +171,7 @@ func TestHysteria2_Error_MissingPort(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria2://password123@127.0.0.1"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -181,7 +181,7 @@ func TestHysteria2_Error_InvalidPort(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria2://password123@127.0.0.1:99999"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -191,7 +191,7 @@ func TestHysteria2_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/hysteria_test.go
+++ b/test/parser/hysteria_test.go
@@ -25,7 +25,7 @@ func TestHysteria_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -52,7 +52,7 @@ func TestHysteria_Basic_WithAuthString(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -80,7 +80,7 @@ func TestHysteria_Basic_WithObfs(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -106,7 +106,7 @@ func TestHysteria_Basic_IPv6Address(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -133,7 +133,7 @@ func TestHysteria_Basic_MultiALPN(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -146,7 +146,7 @@ func TestHysteria_Error_MissingServer(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria://:8080?auth=password123"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -156,7 +156,7 @@ func TestHysteria_Error_MissingPort(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria://127.0.0.1?auth=password123"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -166,7 +166,7 @@ func TestHysteria_Error_InvalidPort(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria://127.0.0.1:99999?auth=password123"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -176,7 +176,7 @@ func TestHysteria_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria2://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/shadowsocks_test.go
+++ b/test/parser/shadowsocks_test.go
@@ -23,7 +23,7 @@ func TestShadowsocks_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestShadowsocks_Basic_IPv6Address(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -71,7 +71,7 @@ func TestShadowsocks_Basic_WithRemark(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -95,7 +95,7 @@ func TestShadowsocks_Advanced_Base64FullEncoded(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -119,7 +119,7 @@ func TestShadowsocks_Advanced_PlainUserPassword(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -143,7 +143,7 @@ func TestShadowsocks_Advanced_ChaCha20Cipher(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -157,7 +157,7 @@ func TestShadowsocks_Error_MissingServer(t *testing.T) {
 	p := &parser.ShadowsocksParser{}
 	input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if !errors.Is(err, parser.ErrInvalidStruct) {
 		t.Errorf("Error is not expected: %v", err)
 	}
@@ -167,7 +167,7 @@ func TestShadowsocks_Error_MissingPort(t *testing.T) {
 	p := &parser.ShadowsocksParser{}
 	input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@127.0.0.1"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if !errors.Is(err, parser.ErrInvalidStruct) {
 		t.Errorf("Error is not expected: %v", err)
 	}
@@ -177,7 +177,7 @@ func TestShadowsocks_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.ShadowsocksParser{}
 	input := "http://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if !errors.Is(err, parser.ErrInvalidPrefix) {
 		t.Errorf("Error is not expected: %v", err)
 	}
--- a/test/parser/shadowsocksr_test.go
+++ b/test/parser/shadowsocksr_test.go
@@ -26,7 +26,7 @@ func TestShadowsocksR_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -54,7 +54,7 @@ func TestShadowsocksR_Basic_WithParams(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -82,7 +82,7 @@ func TestShadowsocksR_Basic_IPv6Address(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -95,7 +95,7 @@ func TestShadowsocksR_Error_InvalidBase64(t *testing.T) {
 	p := &parser.ShadowsocksRParser{}
 	input := "ssr://invalid_base64"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -105,7 +105,7 @@ func TestShadowsocksR_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.ShadowsocksRParser{}
 	input := "ss://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/socks_test.go
+++ b/test/parser/socks_test.go
@@ -22,7 +22,7 @@ func TestSocks_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -44,7 +44,7 @@ func TestSocks_Basic_NoAuth(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -68,7 +68,7 @@ func TestSocks_Basic_IPv6Address(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -93,7 +93,7 @@ func TestSocks_Basic_WithTLS(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -118,7 +118,7 @@ func TestSocks_Basic_WithUDP(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -131,7 +131,7 @@ func TestSocks_Error_MissingServer(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "socks://user:pass@:1080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -141,7 +141,7 @@ func TestSocks_Error_MissingPort(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "socks://user:pass@127.0.0.1"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -151,7 +151,7 @@ func TestSocks_Error_InvalidPort(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "socks://user:pass@127.0.0.1:99999"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -161,7 +161,7 @@ func TestSocks_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "ss://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/trojan_test.go
+++ b/test/parser/trojan_test.go
@@ -21,7 +21,7 @@ func TestTrojan_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -46,7 +46,7 @@ func TestTrojan_Basic_WithTLS(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -75,7 +75,7 @@ func TestTrojan_Basic_WithReality(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -105,7 +105,7 @@ func TestTrojan_Basic_WithWebSocket(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -132,7 +132,7 @@ func TestTrojan_Basic_WithGrpc(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -145,7 +145,7 @@ func TestTrojan_Error_MissingServer(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "trojan://password@:443"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -155,7 +155,7 @@ func TestTrojan_Error_MissingPort(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "trojan://password@127.0.0.1"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -165,7 +165,7 @@ func TestTrojan_Error_InvalidPort(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "trojan://password@127.0.0.1:99999"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -175,7 +175,7 @@ func TestTrojan_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "ss://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/vless_test.go
+++ b/test/parser/vless_test.go
@@ -21,7 +21,7 @@ func TestVless_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestVless_Basic_WithTLS(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -77,7 +77,7 @@ func TestVless_Basic_WithReality(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -107,7 +107,7 @@ func TestVless_Basic_WithWebSocket(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -134,7 +134,7 @@ func TestVless_Basic_WithGrpc(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -164,7 +164,7 @@ func TestVless_Basic_WithHTTP(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -177,7 +177,7 @@ func TestVless_Error_MissingServer(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -187,7 +187,7 @@ func TestVless_Error_MissingPort(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -197,7 +197,7 @@ func TestVless_Error_InvalidPort(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:99999"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -207,7 +207,7 @@ func TestVless_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "ss://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/test/parser/vmess_test.go
+++ b/test/parser/vmess_test.go
@@ -31,7 +31,7 @@ func TestVmess_Basic_SimpleLink(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -64,7 +64,7 @@ func TestVmess_Basic_WithPath(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -97,7 +97,7 @@ func TestVmess_Basic_WithHost(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -131,7 +131,7 @@ func TestVmess_Basic_WithSNI(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -164,7 +164,7 @@ func TestVmess_Basic_WithAlterID(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -192,7 +192,7 @@ func TestVmess_Basic_GRPC(t *testing.T) {
 		},
 	}

-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -205,7 +205,7 @@ func TestVmess_Error_InvalidBase64(t *testing.T) {
 	p := &parser.VmessParser{}
 	input := "vmess://invalid_base64"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -215,7 +215,7 @@ func TestVmess_Error_InvalidJSON(t *testing.T) {
 	p := &parser.VmessParser{}
 	input := "vmess://eyJpbnZhbGlkIjoianNvbn0="

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -225,7 +225,7 @@ func TestVmess_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.VmessParser{}
 	input := "ss://example.com:8080"

-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
--- a/utils/base64.go
+++ b/utils/base64.go
@@ -0,0 +1,31 @@
+package utils
+
+import (
+	"encoding/base64"
+	"strings"
+)
+
+func DecodeBase64(s string, urlSafe bool) (string, error) {
+	s = strings.TrimSpace(s)
+	if len(s)%4 != 0 {
+		s += strings.Repeat("=", 4-len(s)%4)
+	}
+	var decodeStr []byte
+	var err error
+	if urlSafe {
+		decodeStr, err = base64.URLEncoding.DecodeString(s)
+	} else {
+		decodeStr, err = base64.StdEncoding.DecodeString(s)
+	}
+	if err != nil {
+		return "", err
+	}
+	return string(decodeStr), nil
+}
+
+func EncodeBase64(s string, urlSafe bool) string {
+	if urlSafe {
+		return base64.URLEncoding.EncodeToString([]byte(s))
+	}
+	return base64.StdEncoding.EncodeToString([]byte(s))
+}
Author	SHA1	Message	Date
nite	83c24170a0	Update API documentation to reflect changes in configuration format for `GET /convert/:config`, including detailed descriptions of new parameters and structures for `config`, `RuleProvider`, and `Rule`.	2025-07-22 04:19:26 +00:00
nite	80d91efca4	Refactor subscription handling by removing SubConfig model, updating BuildSub function to use ConvertConfig, and enhancing Base64 decoding across parsers. Update routes and frontend to support new configuration format.	2025-07-22 04:09:00 +00:00
nite	83a728a415	Implement YAML unmarshalling for various proxy types and update SOCKS parser to support "socks5" prefix.	2025-07-15 20:14:37 +08:00
Nite	a178d06248	Merge pull request #67 from HaTiWinter/main 修复 GetRawConfHandler 中短链的构建问题 \| Fix URL construction in GetRawConfHandler	2025-07-13 22:49:33 +08:00
HaTiWinter	99d36d93d8	fix URL construction in GetRawConfHandler	2025-07-13 15:57:46 +08:00
nite	0a9892503d	u	2025-07-05 22:57:46 +08:00
nite	ff81d03492	u	2025-07-05 22:54:02 +08:00
nite	0fa95888cb	Fix URL construction in GetRawConfHandler to ensure proper HTTP scheme is used.	2025-07-01 02:22:46 +08:00
nite	b44703fa0f	Enhance Trojan, Vless, and Vmess parsers.	2025-07-01 02:06:33 +08:00