mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-17 17:32:15 +08:00
346 lines
9.0 KiB
TypeScript
346 lines
9.0 KiB
TypeScript
const URI_SCHEME_RE = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\//
|
|
|
|
export function normalizeUriAndGetScheme(input: string): {
|
|
uri: string
|
|
scheme: string
|
|
} {
|
|
const trimmed = input.trim()
|
|
const match = URI_SCHEME_RE.exec(trimmed)
|
|
if (!match) {
|
|
const schemeGuess = (trimmed.split('://')[0] ?? '').toLowerCase()
|
|
return { uri: trimmed, scheme: schemeGuess }
|
|
}
|
|
|
|
const scheme = match[1].toLowerCase()
|
|
return { uri: scheme + trimmed.slice(match[1].length), scheme }
|
|
}
|
|
|
|
export function stripUriScheme(
|
|
uri: string,
|
|
expectedSchemes: string | readonly string[],
|
|
errorMessage: string,
|
|
): string {
|
|
const match = URI_SCHEME_RE.exec(uri)
|
|
if (!match) {
|
|
throw new Error(errorMessage)
|
|
}
|
|
const scheme = match[1].toLowerCase()
|
|
|
|
const expected =
|
|
typeof expectedSchemes === 'string' ? [expectedSchemes] : expectedSchemes
|
|
if (!expected.includes(scheme)) {
|
|
throw new Error(errorMessage)
|
|
}
|
|
return uri.slice(match[0].length)
|
|
}
|
|
|
|
export function getIfNotBlank(
|
|
value: string | undefined,
|
|
dft?: string,
|
|
): string | undefined {
|
|
return value && value.trim() !== '' ? value : dft
|
|
}
|
|
|
|
export function getIfPresent<T>(
|
|
value: T | null | undefined,
|
|
dft?: T,
|
|
): T | undefined {
|
|
return value !== null && value !== undefined ? value : dft
|
|
}
|
|
|
|
export function isPresent(value: any): boolean {
|
|
return value !== null && value !== undefined
|
|
}
|
|
|
|
export function trimStr(str: string | undefined): string | undefined {
|
|
return str ? str.trim() : str
|
|
}
|
|
|
|
export function safeDecodeURIComponent(
|
|
value: string | undefined,
|
|
): string | undefined {
|
|
if (value === undefined) return undefined
|
|
try {
|
|
return decodeURIComponent(value)
|
|
} catch {
|
|
return value
|
|
}
|
|
}
|
|
|
|
export function decodeAndTrim(value: string | undefined): string | undefined {
|
|
const decoded = safeDecodeURIComponent(value)
|
|
const trimmed = decoded?.trim()
|
|
return trimmed ? trimmed : undefined
|
|
}
|
|
|
|
export function splitOnce(input: string, delimiter: string): [string, string?] {
|
|
const idx = input.indexOf(delimiter)
|
|
if (idx === -1) return [input]
|
|
return [input.slice(0, idx), input.slice(idx + delimiter.length)]
|
|
}
|
|
|
|
export function parseQueryString(
|
|
query: string | undefined,
|
|
): Record<string, string | undefined> {
|
|
const out: Record<string, string | undefined> = {}
|
|
if (!query) return out
|
|
for (const part of query.split('&')) {
|
|
if (!part) continue
|
|
const [keyRaw, valueRaw] = splitOnce(part, '=')
|
|
const key = keyRaw.trim()
|
|
if (!key) continue
|
|
out[key] =
|
|
valueRaw === undefined
|
|
? undefined
|
|
: (safeDecodeURIComponent(valueRaw) ?? valueRaw)
|
|
}
|
|
return out
|
|
}
|
|
|
|
function normalizeQueryKey(key: string): string {
|
|
return key.replace(/_/g, '-')
|
|
}
|
|
|
|
export function parseQueryStringNormalized(
|
|
query: string | undefined,
|
|
): Record<string, string | undefined> {
|
|
const raw = parseQueryString(query)
|
|
const normalized: Record<string, string | undefined> = {}
|
|
for (const [key, value] of Object.entries(raw)) {
|
|
normalized[normalizeQueryKey(key)] = value
|
|
}
|
|
return normalized
|
|
}
|
|
|
|
export function parseBool(value: string | undefined): boolean | undefined {
|
|
if (value === undefined) return undefined
|
|
return /^(?:true|1)$/i.test(value)
|
|
}
|
|
|
|
export function parseBoolOrPresence(value: string | undefined): boolean {
|
|
if (value === undefined) return true
|
|
const trimmed = value.trim()
|
|
if (trimmed === '') return true
|
|
return /^(?:true|1)$/i.test(trimmed)
|
|
}
|
|
|
|
export function parseVlessFlow(value: string | undefined): string | undefined {
|
|
const flow = getIfNotBlank(value)
|
|
if (!flow) return undefined
|
|
if (/^none$/i.test(flow)) return undefined
|
|
if (!/^[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(flow)) return undefined
|
|
return flow
|
|
}
|
|
|
|
export function parseInteger(value: string | undefined): number | undefined {
|
|
if (value === undefined) return undefined
|
|
const parsed = Number.parseInt(value, 10)
|
|
return Number.isNaN(parsed) ? undefined : parsed
|
|
}
|
|
|
|
function parsePortStrict(
|
|
value: string | number | null | undefined,
|
|
): number | undefined {
|
|
if (value === null || value === undefined) return undefined
|
|
const raw = String(value).trim()
|
|
if (!/^\d+$/.test(raw)) return undefined
|
|
const parsed = Number.parseInt(raw, 10)
|
|
if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 65535) {
|
|
return undefined
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
export function parseRequiredPort(
|
|
value: string | number | null | undefined,
|
|
errorMessage: string,
|
|
): number {
|
|
const parsed = parsePortStrict(value)
|
|
if (parsed === undefined) {
|
|
throw new Error(errorMessage)
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
export function parsePortOrDefault(
|
|
port: string | undefined,
|
|
dft: number,
|
|
): number {
|
|
return parseInteger(port) ?? dft
|
|
}
|
|
|
|
const IP_VERSIONS = [
|
|
'dual',
|
|
'ipv4',
|
|
'ipv6',
|
|
'ipv4-prefer',
|
|
'ipv6-prefer',
|
|
] as const
|
|
|
|
export function parseIpVersion(
|
|
value: string | undefined,
|
|
): (typeof IP_VERSIONS)[number] {
|
|
return value && IP_VERSIONS.includes(value as (typeof IP_VERSIONS)[number])
|
|
? (value as (typeof IP_VERSIONS)[number])
|
|
: 'dual'
|
|
}
|
|
|
|
export type UrlLikeParts = {
|
|
auth?: string
|
|
host: string
|
|
port?: string
|
|
query?: string
|
|
fragment?: string
|
|
}
|
|
|
|
export function normalizeHost(host: string): string {
|
|
return host.startsWith('[') && host.endsWith(']') ? host.slice(1, -1) : host
|
|
}
|
|
|
|
const URLLIKE_RE =
|
|
/^(?:(?<auth>.*?)@)?(?<host>.*?)(?::(?<port>\d+))?\/?(?:\?(?<query>.*?))?(?:#(?<fragment>.*?))?$/
|
|
|
|
export function parseUrlLike(
|
|
input: string,
|
|
options: { requireAuth: true; errorMessage: string },
|
|
): UrlLikeParts & { auth: string }
|
|
export function parseUrlLike(
|
|
input: string,
|
|
options: { requireAuth?: false; errorMessage: string },
|
|
): UrlLikeParts
|
|
export function parseUrlLike(
|
|
input: string,
|
|
options: { requireAuth?: boolean; errorMessage: string },
|
|
): UrlLikeParts {
|
|
const match = URLLIKE_RE.exec(input)
|
|
const groups = (match?.groups ?? {}) as {
|
|
auth?: string
|
|
host?: string
|
|
port?: string
|
|
query?: string
|
|
fragment?: string
|
|
}
|
|
if (!match || groups.host === undefined) {
|
|
throw new Error(options.errorMessage)
|
|
}
|
|
|
|
const auth = getIfNotBlank(groups.auth)
|
|
if (options.requireAuth && !auth) {
|
|
throw new Error(options.errorMessage)
|
|
}
|
|
|
|
const result: UrlLikeParts = {
|
|
auth,
|
|
host: normalizeHost(groups.host),
|
|
port: groups.port,
|
|
query: groups.query,
|
|
fragment: groups.fragment,
|
|
}
|
|
return options.requireAuth
|
|
? ({ ...result, auth } as UrlLikeParts & { auth: string })
|
|
: result
|
|
}
|
|
|
|
export function isIPv4(address: string): boolean {
|
|
// Check if the address is IPv4
|
|
const ipv4Regex = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/
|
|
return ipv4Regex.test(address)
|
|
}
|
|
|
|
export function isIPv6(address: string): boolean {
|
|
// Check if the address is IPv6 - simplified regex to avoid backreference issues
|
|
const ipv6Regex =
|
|
/^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::$|^::1$|^([0-9a-fA-F]{1,4}:)*::([0-9a-fA-F]{1,4}:)*[0-9a-fA-F]{1,4}$/
|
|
return ipv6Regex.test(address)
|
|
}
|
|
|
|
export function decodeBase64OrOriginal(str: string): string {
|
|
const normalized = str
|
|
.replace(/[\r\n\s]/g, '')
|
|
.replace(/-/g, '+')
|
|
.replace(/_/g, '/')
|
|
|
|
const padLen = normalized.length % 4
|
|
const padded = padLen === 0 ? normalized : normalized + '='.repeat(4 - padLen)
|
|
|
|
try {
|
|
const decodedArray = new Uint8Array(
|
|
atob(padded)
|
|
.split('')
|
|
.map((c) => c.charCodeAt(0)),
|
|
)
|
|
const decoded = new TextDecoder('utf-8', { fatal: true }).decode(
|
|
decodedArray,
|
|
)
|
|
// Heuristic: only accept "text-like" results to avoid accidentally decoding
|
|
// non-base64 strings that happen to be decodable.
|
|
for (let i = 0; i < decoded.length; i++) {
|
|
const code = decoded.charCodeAt(i)
|
|
if (code === 9 || code === 10 || code === 13) continue
|
|
if (code < 32 || code === 127) {
|
|
return str
|
|
}
|
|
}
|
|
return decoded
|
|
} catch {
|
|
return str
|
|
}
|
|
}
|
|
|
|
const CIPHER_ALIASES: Record<string, CipherType> = {
|
|
'chacha20-poly1305': 'chacha20-ietf-poly1305',
|
|
}
|
|
|
|
const KNOWN_CIPHERS = new Set<CipherType>([
|
|
'none',
|
|
'auto',
|
|
'dummy',
|
|
'aes-128-gcm',
|
|
'aes-192-gcm',
|
|
'aes-256-gcm',
|
|
'lea-128-gcm',
|
|
'lea-192-gcm',
|
|
'lea-256-gcm',
|
|
'aes-128-gcm-siv',
|
|
'aes-256-gcm-siv',
|
|
'2022-blake3-aes-128-gcm',
|
|
'2022-blake3-aes-256-gcm',
|
|
'aes-128-cfb',
|
|
'aes-192-cfb',
|
|
'aes-256-cfb',
|
|
'aes-128-ctr',
|
|
'aes-192-ctr',
|
|
'aes-256-ctr',
|
|
'chacha20',
|
|
'chacha20-ietf',
|
|
'chacha20-ietf-poly1305',
|
|
'2022-blake3-chacha20-poly1305',
|
|
'rabbit128-poly1305',
|
|
'xchacha20-ietf-poly1305',
|
|
'xchacha20',
|
|
'aegis-128l',
|
|
'aegis-256',
|
|
'aez-384',
|
|
'deoxys-ii-256-128',
|
|
'rc4-md5',
|
|
])
|
|
|
|
export function getCipher(value: unknown): CipherType {
|
|
if (value === undefined) return 'none'
|
|
if (typeof value !== 'string') return 'auto'
|
|
const aliased = CIPHER_ALIASES[value] ?? value
|
|
return KNOWN_CIPHERS.has(aliased as CipherType)
|
|
? (aliased as CipherType)
|
|
: 'auto'
|
|
}
|
|
|
|
export function firstString(value: any): string | undefined {
|
|
if (value === null || value === undefined) return undefined
|
|
if (Array.isArray(value)) {
|
|
if (value.length === 0) return undefined
|
|
const first = value[0]
|
|
return first === null || first === undefined ? undefined : String(first)
|
|
}
|
|
return String(value)
|
|
}
|