nodelistparser 0.0.0 → 0.1.2

package/dist/cjs/index.js

@@ -0,0 +1,515 @@
+const boolean = (text)=>text === 'true';
+const number = Number;
+const comma = (text)=>text.split(',').map((piece)=>piece.trim());
+function assign(text) {
+    const signIndex = text.indexOf('=');
+    return signIndex === -1 ? [
+        '',
+        ''
+    ] : [
+        text.slice(0, signIndex).trim(),
+        text.slice(signIndex + 1).trim()
+    ];
+}
+
+const boolKeys = new Set([
+    'udp-relay',
+    'tfo',
+    'reuse',
+    'skip-cert-verify',
+    'tls',
+    'vmess-aead',
+    'ws'
+]);
+const isProxyBoolKey = (key)=>boolKeys.has(key);
+const numKeys = new Set([
+    'version',
+    'download-bandwidth',
+    'port-hopping-interval',
+    'udp-port'
+]);
+const isProxyNumKey = (key)=>numKeys.has(key);
+const arrKeys = new Set([]);
+const isProxyArrKey = (key)=>arrKeys.has(key);
+const strKeys = new Set([
+    'username',
+    'password',
+    'sni',
+    'encrypt-method',
+    'psk',
+    'obfs',
+    'obfs-host',
+    'uuid',
+    'alpn',
+    'block-quic',
+    'ws-path',
+    'ws-headers',
+    'port-hopping'
+]);
+const isProxyStrKey = (key)=>strKeys.has(key);
+const UNSUPPORTED_VALUE = Symbol('unsupported');
+function decode$1(raw) {
+    const parsePart = (part)=>{
+        const [key, value] = assign(part);
+        if (isProxyBoolKey(key)) {
+            return [
+                key,
+                boolean(value)
+            ];
+        }
+        if (isProxyNumKey(key)) {
+            return [
+                key,
+                number(value)
+            ];
+        }
+        if (isProxyArrKey(key)) {
+            return [
+                key,
+                comma(value)
+            ];
+        }
+        if (isProxyStrKey(key)) {
+            if (value[0] === '"' && value.endsWith('"') || value[0] === '\'' && value.endsWith('\'')) {
+                return [
+                    key,
+                    value.slice(1, -1)
+                ];
+            }
+            return [
+                key,
+                value
+            ];
+        }
+        return [
+            key,
+            UNSUPPORTED_VALUE
+        ];
+    };
+    const [name, parts] = assign(raw);
+    const [type, server, mayPort, ...rest] = comma(parts);
+    const port = number(mayPort);
+    const restDetails = Object.fromEntries(rest.map(parsePart));
+    const shared = {
+        raw,
+        name,
+        server,
+        port,
+        tfo: restDetails.tfo,
+        blockQuic: restDetails['block-quic']
+    };
+    switch(type){
+        case 'snell':
+            {
+                return {
+                    type: 'snell',
+                    psk: restDetails.psk,
+                    version: restDetails.version,
+                    reuse: restDetails.reuse,
+                    ...shared
+                };
+            }
+        case 'ss':
+            {
+                return {
+                    type: 'ss',
+                    cipher: restDetails['encrypt-method'],
+                    password: restDetails.password,
+                    udp: restDetails['udp-relay'],
+                    obfs: restDetails.obfs,
+                    obfsHost: restDetails['obfs-host'],
+                    obfsUri: restDetails['obfs-uri'],
+                    udpPort: restDetails['udp-port'],
+                    ...shared
+                };
+            }
+        case 'trojan':
+            {
+                return {
+                    type: 'trojan',
+                    password: restDetails.password,
+                    sni: restDetails.sni,
+                    skipCertVerify: restDetails['skip-cert-verify'],
+                    udp: restDetails['udp-relay'],
+                    ...shared
+                };
+            }
+        case 'tuic':
+            {
+                return {
+                    type: 'tuic',
+                    sni: restDetails.sni,
+                    uuid: restDetails.uuid,
+                    alpn: restDetails.alpn,
+                    password: restDetails.password,
+                    version: restDetails.version,
+                    ...shared
+                };
+            }
+        case 'socks5':
+            {
+                return {
+                    type: 'socks5',
+                    username: rest[0],
+                    password: rest[1],
+                    udp: restDetails['udp-relay'],
+                    ...shared
+                };
+            }
+        case 'http':
+            {
+                return {
+                    type: 'http',
+                    username: rest[0],
+                    password: rest[1],
+                    ...shared
+                };
+            }
+        case 'vmess':
+            {
+                return {
+                    type: 'vmess',
+                    username: restDetails.username,
+                    tls: restDetails.tls,
+                    vmessAead: restDetails['vmess-aead'],
+                    ws: restDetails.ws,
+                    wsPath: restDetails['ws-path'],
+                    wsHeaders: restDetails['ws-headers'],
+                    skipCertVerify: restDetails['skip-cert-verify'],
+                    udp: restDetails['udp-relay'],
+                    sni: restDetails.sni,
+                    ...shared
+                };
+            }
+        case 'hysteria2':
+            return {
+                type: 'hysteria2',
+                password: restDetails.password,
+                skipCertVerify: restDetails['skip-cert-verify'],
+                downloadBandwidth: restDetails['download-bandwidth'],
+                portHopping: restDetails['port-hopping'],
+                portHoppingInterval: restDetails['port-hopping-interval'],
+                ...shared
+            };
+        default:
+            throw new TypeError(`Unsupported type: ${type} (surge decode)`);
+    }
+// console.log({
+//   name, type, server, port, restDetails
+// });
+}
+function assertNever(value, msg) {
+    throw new TypeError(`Unsupported type: ${msg}`);
+}
+const joinString = (arr)=>arr.filter(Boolean).join(', ');
+function encode$1(config) {
+    const shared = [
+        config.tfo && 'tfo=true',
+        config.blockQuic && `block-quic=${config.blockQuic}`
+    ];
+    switch(config.type){
+        case 'snell':
+            return joinString([
+                `${config.name} = snell, ${config.server}, ${config.port}, psk=${config.psk}, version=${config.version}, reuse=${config.reuse}`,
+                ...shared
+            ]);
+        case 'ss':
+            return joinString([
+                `${config.name} = ss, ${config.server}, ${config.port}, encrypt-method=${config.cipher}, password=${config.password}`,
+                config.udp && 'udp-relay=true',
+                config.udpPort && `udp-port=${config.udpPort}`,
+                config.obfs && `obfs=${config.obfs}`,
+                config.obfsHost && `obfs-host=${config.obfsHost}`,
+                config.obfsUri && `obfs-uri=${config.obfsUri}`,
+                ...shared
+            ]);
+        case 'trojan':
+            return joinString([
+                `${config.name} = trojan, ${config.server}, ${config.port}, password=${config.password}`,
+                config.sni && `sni=${config.sni}`,
+                config.skipCertVerify && 'skip-cert-verify=true',
+                ...shared,
+                config.udp && 'udp-relay=true'
+            ]);
+        case 'tuic':
+            return joinString([
+                `${config.name} = tuic, ${config.server}, ${config.port}, sni=${config.sni}, uuid=${config.uuid}, alpn=${config.alpn}, password=${config.password}, version=${config.version}`,
+                ...shared
+            ]);
+        case 'socks5':
+            return joinString([
+                `${config.name} = socks5, ${config.server}, ${config.port}, ${config.username}, ${config.password}`,
+                config.udp && 'udp-relay=true',
+                ...shared
+            ]);
+        case 'http':
+            return joinString([
+                `${config.name} = http, ${config.server}, ${config.port}, ${config.username}, ${config.password}`,
+                // no udp support for http
+                ...shared
+            ]);
+        case 'vmess':
+            return joinString([
+                `${config.name} = vmess, ${config.server}, ${config.port}`,
+                `username=${config.username}`,
+                `tls=${config.tls}`,
+                `vmess-aead=${config.vmessAead}`,
+                'ws=true',
+                config.wsPath && `ws-path=${config.wsPath[0] === '/' ? config.wsPath : `/${config.wsPath}`}`,
+                config.wsHeaders && `ws-headers=${config.wsHeaders}`,
+                `skip-cert-verify=${config.skipCertVerify}`,
+                `tfo=${config.tfo}`,
+                `udp-relay=${config.udp}`
+            ]);
+        case 'hysteria2':
+            return joinString([
+                `${config.name} = hysteria2, ${config.server}, ${config.port}`,
+                `password=${config.password}`,
+                `download-bandwidth=${config.downloadBandwidth}`,
+                config.portHopping && `port-hopping="${config.portHopping}"`,
+                config.portHoppingInterval && `port-hopping-interval=${config.portHoppingInterval}`,
+                `skip-cert-verify=${config.skipCertVerify}`,
+                ...shared
+            ]);
+        default:
+            assertNever(config, `Unsupported type: ${config.type} (clash encode)`);
+    }
+}
+
+var index$2 = {
+  __proto__: null,
+  decode: decode$1,
+  encode: encode$1
+};
+
+function decode(config) {
+    if (!('type' in config) || typeof config.type !== 'string') {
+        throw new TypeError('Missing or invalid type field');
+    }
+    const raw = JSON.stringify(config);
+    switch(config.type){
+        case 'http':
+            return {
+                type: 'http',
+                name: config.name,
+                server: config.server,
+                port: Number(config.port),
+                username: config.username,
+                password: config.password,
+                raw
+            };
+        case 'ss':
+            return {
+                type: 'ss',
+                name: config.name,
+                server: config.server,
+                port: Number(config.port),
+                cipher: config.cipher,
+                password: config.password,
+                udp: config.udp || false,
+                obfs: config.plugin === 'obfs' ? config['plugin-opts'].mode : undefined,
+                raw
+            };
+        case 'socks5':
+            return {
+                type: 'socks5',
+                name: config.name,
+                server: config.server,
+                port: Number(config.port),
+                username: config.username,
+                password: config.password,
+                udp: config.udp || false,
+                raw
+            };
+        case 'trojan':
+            return {
+                type: 'trojan',
+                name: config.name,
+                server: config.server,
+                port: Number(config.port),
+                password: config.password,
+                sni: config.sni,
+                skipCertVerify: config['skip-cert-verify'] || false,
+                udp: config.udp || false,
+                raw
+            };
+        case 'vmess':
+            return {
+                type: 'vmess',
+                name: config.name,
+                server: config.server,
+                port: Number(config.port),
+                username: config.uuid,
+                vmessAead: config.alterId === 1 || config.alterId === '1',
+                sni: config.servername,
+                ws: config.network === 'ws',
+                wsPath: config['ws-path'],
+                wsHeaders: config['ws-headers'] ? Object.entries(config['ws-headers']).map(([key, value])=>`${key}:${value}`).join(', ') : undefined,
+                tls: config.tls || false,
+                udp: config.udp ?? true,
+                raw,
+                skipCertVerify: config['skip-cert-verify'] || false
+            };
+        default:
+            throw new TypeError(`Unsupported type: ${config.type} (clash decode)`);
+    }
+}
+function encode(config) {
+    const shared = {
+        tfo: config.tfo
+    };
+    switch(config.type){
+        case 'ss':
+            return {
+                name: config.name,
+                type: 'ss',
+                server: config.server,
+                port: config.port,
+                cipher: config.cipher,
+                password: config.password,
+                udp: config.udp,
+                ...config.obfs ? {
+                    plugin: 'obfs',
+                    'plugin-opts': {
+                        mode: config.obfs,
+                        host: config.obfsHost,
+                        uri: config.obfsUri
+                    }
+                } : {},
+                ...shared
+            };
+        case 'trojan':
+            return {
+                name: config.name,
+                type: 'trojan',
+                server: config.server,
+                port: config.port,
+                password: config.password,
+                sni: config.sni,
+                'skip-cert-verify': config.skipCertVerify,
+                udp: config.udp,
+                ...shared
+            };
+        case 'tuic':
+            return {
+                name: config.name,
+                type: 'tuic',
+                server: config.server,
+                port: config.port,
+                sni: config.sni,
+                uuid: config.uuid,
+                alpn: config.alpn.split(',').map((x)=>x.trim()),
+                token: config.password,
+                version: config.version,
+                udp: true,
+                ...shared
+            };
+        case 'socks5':
+            return {
+                name: config.name,
+                type: 'socks5',
+                server: config.server,
+                port: config.port,
+                username: config.username,
+                password: config.password,
+                udp: config.udp,
+                ...shared
+            };
+        case 'http':
+            return {
+                name: config.name,
+                type: 'http',
+                server: config.server,
+                port: config.port,
+                username: config.username,
+                password: config.password,
+                ...shared
+            };
+        case 'vmess':
+            return {
+                alterId: config.vmessAead ? 0 : undefined,
+                tls: config.tls,
+                udp: config.udp,
+                uuid: config.username,
+                name: config.name,
+                servername: config.sni,
+                'ws-path': config.wsPath,
+                server: config.server,
+                'ws-headers': config.wsHeaders ? parseStringToObject(config.wsHeaders) : undefined,
+                cipher: 'auto',
+                'ws-opts': {
+                    path: config.wsPath,
+                    headers: config.wsHeaders ? parseStringToObject(config.wsHeaders) : undefined
+                },
+                type: 'vmess',
+                port: config.port,
+                network: config.ws ? 'ws' : 'tcp'
+            };
+        case 'hysteria2':
+            return {
+                name: config.name,
+                type: 'hysteria2',
+                server: config.server,
+                port: config.port,
+                ports: config.portHopping,
+                password: config.password,
+                down: config.downloadBandwidth + ' Mbps',
+                'skip-cert-verify': config.skipCertVerify
+            };
+        default:
+            throw new TypeError(`Unsupported type: ${config.type} (clash encode)`);
+    }
+}
+function parseStringToObject(input) {
+    return input.split(',').reduce((acc, pair)=>{
+        const [key, value] = pair.split(':');
+        acc[key.trim()] = value.trim();
+        return acc;
+    }, {});
+}
+
+var index$1 = {
+  __proto__: null,
+  decode: decode,
+  encode: encode
+};
+
+function decodeOne(sip002) {
+    // ss://YWVzLTEyOC1nY206YzMxNWFhOGMtNGU1NC00MGRjLWJkYzctYzFjMjEwZjIxYTNi@ss1.meslink.xyz:10009#%F0%9F%87%AD%F0%9F%87%B0%20HK1%20HKT
+    const [_type, payload] = sip002.split('://');
+    const [userInfo, server] = payload.split('@');
+    let cipher, password;
+    if (userInfo.includes(':')) {
+        [cipher, password] = userInfo.split(':');
+    } else {
+        [cipher, password] = atob(userInfo).split(':');
+    }
+    const [serverName, _1] = server.split(':');
+    const [_2, encodedName] = _1.split('#');
+    const [port, _plugins] = _2.split('/');
+    // TODO: implement plugin parsing
+    return {
+        raw: sip002,
+        type: 'ss',
+        name: decodeURIComponent(encodedName),
+        server: serverName,
+        port: number(port),
+        cipher,
+        password,
+        udp: true
+    };
+}
+function decodeMultiline(text) {
+    const lines = atob(text).replaceAll('\r\n', '\n').split('\n');
+    return lines.filter(Boolean).map((line)=>decodeOne(line));
+}
+
+var index = {
+  __proto__: null,
+  decodeMultiline: decodeMultiline,
+  decodeOne: decodeOne
+};
+
+exports.clash = index$1;
+exports.ss = index;
+exports.surge = index$2;