@bbk47/toolbox 1.0.8 → 2.0.0

package/lib/transport/transport.js

@@ -1,38 +1,41 @@
-const { websocketSend, tcpsocketSend, bindWebsocket, bindStreamSocket } = require('./helper');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+const helper_1 = require("./helper");
 class Transport {
     constructor(opts) {
         this.type = opts.type;
         this.conn = opts.conn;
     }
-
     sendPacket(binarydata) {
         if (this.type === 'ws') {
-            websocketSend(this.conn, binarydata);
-        } else {
-            tcpsocketSend(this.conn, binarydata);
+            (0, helper_1.websocketSend)(this.conn, binarydata);
+        }
+        else {
+            (0, helper_1.tcpsocketSend)(this.conn, binarydata);
         }
     }
-
     bindEvents(onData, onError, onClose) {
         if (this.type === 'ws') {
-            bindWebsocket(this.conn, onData, onError, onClose);
-        } else {
-            bindStreamSocket(this.conn, onData, onError, onClose);
+            (0, helper_1.bindWebsocket)(this.conn, onData, onError, onClose);
+        }
+        else {
+            (0, helper_1.bindStreamSocket)(this.conn, onData, onError, onClose);
         }
     }
-
     close() {
         try {
             if (this.type === 'ws' || this.type === 'h2') {
                 this.conn.close();
-            } else {
+            }
+            else {
                 this.conn.destroy();
             }
-        } catch (err) {
+        }
+        catch (_err) {
             // ignore
         }
     }
 }
-
-module.exports = Transport;
+exports.Transport = Transport;
+//# sourceMappingURL=transport.js.map

package/lib/transport/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport/transport.ts"],"names":[],"mappings":";;;AAEA,qCAAyF;AAezF,MAAa,SAAS;IAIlB,YAAY,IAAkD;QAC1D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,UAAU,CAAC,UAAkB;QACzB,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACrB,IAAA,sBAAa,EAAC,IAAI,CAAC,IAA4B,EAAE,UAAU,CAAC,CAAC;QACjE,CAAC;aAAM,CAAC;YACJ,IAAA,sBAAa,EAAC,IAAI,CAAC,IAA6B,EAAE,UAAU,CAAC,CAAC;QAClE,CAAC;IACL,CAAC;IAED,UAAU,CAAC,MAAoB,EAAE,OAAsB,EAAE,OAAsB;QAC3E,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACrB,IAAA,sBAAa,EAAC,IAAI,CAAC,IAA4B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAC/E,CAAC;aAAM,CAAC;YACJ,IAAA,yBAAgB,EAAC,IAAI,CAAC,IAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACjE,CAAC;IACL,CAAC;IAED,KAAK;QACD,IAAI,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC1C,IAAI,CAAC,IAAY,CAAC,KAAK,EAAE,CAAC;YAC/B,CAAC;iBAAM,CAAC;gBACH,IAAI,CAAC,IAAY,CAAC,OAAO,EAAE,CAAC;YACjC,CAAC;QACL,CAAC;QAAC,OAAO,IAAI,EAAE,CAAC;YACZ,SAAS;QACb,CAAC;IACL,CAAC;CACJ;AApCD,8BAoCC"}

package/lib/uuid.d.ts

@@ -0,0 +1,2 @@
+export default function uuid(): string;
+//# sourceMappingURL=uuid.d.ts.map

package/lib/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"AAkCA,MAAM,CAAC,OAAO,UAAU,IAAI,IAAI,MAAM,CAErC"}

package/lib/uuid.js

@@ -1,16 +1,16 @@
-// const uuid = require('uuid').v4;
-
-var lut = [];
-for (var i = 0; i < 256; i++) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uuid;
+const lut = [];
+for (let i = 0; i < 256; i++) {
     lut[i] = (i < 16 ? '0' : '') + i.toString(16);
 }
 function e7() {
-    var d0 = (Math.random() * 0xffffffff) | 0;
-    var d1 = (Math.random() * 0xffffffff) | 0;
-    var d2 = (Math.random() * 0xffffffff) | 0;
-    var d3 = (Math.random() * 0xffffffff) | 0;
-    return (
-        lut[d0 & 0xff] +
+    const d0 = (Math.random() * 0xffffffff) | 0;
+    const d1 = (Math.random() * 0xffffffff) | 0;
+    const d2 = (Math.random() * 0xffffffff) | 0;
+    const d3 = (Math.random() * 0xffffffff) | 0;
+    return (lut[d0 & 0xff] +
         lut[(d0 >> 8) & 0xff] +
         lut[(d0 >> 16) & 0xff] +
         lut[(d0 >> 24) & 0xff] +
@@ -29,15 +29,9 @@ function e7() {
         lut[d3 & 0xff] +
         lut[(d3 >> 8) & 0xff] +
         lut[(d3 >> 16) & 0xff] +
-        lut[(d3 >> 24) & 0xff]
-    );
+        lut[(d3 >> 24) & 0xff]);
 }
-
-function getRamdomUUID() {
-    const id = e7();
-    return id.replace(/-/g, '');
+function uuid() {
+    return e7().replace(/-/g, '');
 }
-
-// console.log(getRamdomUUID());
-
-module.exports = getRamdomUUID;
+//# sourceMappingURL=uuid.js.map

package/lib/uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.js","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":";;AAkCA,uBAEC;AApCD,MAAM,GAAG,GAAa,EAAE,CAAC;AACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;IAC3B,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,EAAE;IACP,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC5C,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC5C,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC5C,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC5C,OAAO,CACH,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;QACrB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACtB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACtB,GAAG;QACH,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;QACrB,GAAG;QACH,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QAC/B,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACtB,GAAG;QACH,GAAG,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QACvB,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;QACrB,GAAG;QACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACtB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACtB,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;QACrB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QACtB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,CACzB,CAAC;AACN,CAAC;AAED,SAAwB,IAAI;IACxB,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAClC,CAAC"}

package/package.json

@@ -1,10 +1,18 @@
 {
     "name": "@bbk47/toolbox",
-    "version": "1.0.8",
+    "version": "2.0.0",
     "description": "toolbox for bbk",
     "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "files": [
+        "lib",
+        "src"
+    ],
     "scripts": {
-        "test": "mocha ./test"
+        "build": "tsc",
+        "test": "jest",
+        "test:coverage": "jest --coverage",
+        "prepublishOnly": "npm run build && npm test"
     },
     "repository": {
         "type": "git",
@@ -17,10 +25,15 @@
     },
     "homepage": "https://github.com/bbk47/toolboxjs#readme",
     "dependencies": {
-        "date-format": "^3.0.0",
         "ws": "2.3.x"
     },
     "devDependencies": {
-        "mocha": "^5.2.0"
+        "@jest/globals": "^30.4.1",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^26.0.0",
+        "@types/ws": "^8.18.1",
+        "jest": "^30.4.2",
+        "ts-jest": "^29.4.11",
+        "typescript": "^6.0.3"
     }
 }

package/src/deferred.ts

@@ -0,0 +1,14 @@
+export interface Deferred<T = any> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+
+export default function deferred<T = any>(): Deferred<T> {
+    const defer = {} as Deferred<T>;
+    defer.promise = new Promise<T>((resolve, reject) => {
+        defer.resolve = resolve;
+        defer.reject = reject;
+    });
+    return defer;
+}

package/src/encrypt.ts

@@ -0,0 +1,119 @@
+import crypto from 'crypto';
+
+type CipherKey = string;
+interface KeyIVCache {
+    [key: string]: [Buffer, Buffer];
+}
+interface KeyIV {
+    key: Buffer;
+    iv: Buffer;
+}
+
+const bytes_to_key_results: KeyIVCache = {};
+
+const EVP_BytesToKey = function (
+    password: Buffer,
+    key_len: number,
+    iv_len: number
+): [Buffer, Buffer] {
+    const cacheKey = `${password}:${key_len}:${iv_len}`;
+    if (bytes_to_key_results[cacheKey]) {
+        return bytes_to_key_results[cacheKey];
+    }
+    const m: Buffer[] = [];
+    let i = 0;
+    let count = 0;
+    while (count < key_len + iv_len) {
+        const md5hash = crypto.createHash('md5');
+        let data: Buffer = password;
+        if (i > 0) {
+            data = Buffer.concat([m[i - 1], password]);
+        }
+        md5hash.update(data);
+        const d = md5hash.digest();
+        m.push(d);
+        count += d.length;
+        i += 1;
+    }
+    const ms = Buffer.concat(m);
+    const key = ms.slice(0, key_len);
+    const iv = ms.slice(key_len, key_len + iv_len);
+    bytes_to_key_results[cacheKey] = [key, iv];
+    return [key, iv];
+};
+
+export type CipherMethod =
+    | 'aes-128-cfb'
+    | 'aes-192-cfb'
+    | 'aes-256-cfb'
+    | 'bf-cfb'
+    | 'camellia-128-cfb'
+    | 'camellia-192-cfb'
+    | 'camellia-256-cfb'
+    | 'cast5-cfb'
+    | 'des-cfb'
+    | 'idea-cfb'
+    | 'rc2-cfb'
+    | 'rc4'
+    | 'seed-cfb';
+
+const method_supported: Record<CipherMethod, [number, number]> = {
+    'aes-128-cfb': [16, 16],
+    'aes-192-cfb': [24, 16],
+    'aes-256-cfb': [32, 16],
+    'bf-cfb': [16, 8],
+    'camellia-128-cfb': [16, 16],
+    'camellia-192-cfb': [24, 16],
+    'camellia-256-cfb': [32, 16],
+    'cast5-cfb': [16, 8],
+    'des-cfb': [8, 8],
+    'idea-cfb': [16, 8],
+    'rc2-cfb': [16, 8],
+    rc4: [16, 0],
+    'seed-cfb': [16, 16],
+};
+
+export class Encryptor {
+    key: CipherKey;
+    method: CipherMethod;
+    _EVP_KEY: Buffer;
+    _IV: Buffer;
+
+    constructor(key: string = 'MVP123', method: CipherMethod = 'aes-256-cfb') {
+        this.key = key;
+        this.method = method;
+        if (!method_supported[this.method]) {
+            throw new Error('Not support method!');
+        }
+        const keyIV = this.getKeyIV(key, method);
+        this._EVP_KEY = keyIV.key;
+        this._IV = keyIV.iv;
+    }
+
+    get_cipher_len(method: string): [number, number] {
+        const m = method.toLowerCase() as CipherMethod;
+        return method_supported[m];
+    }
+
+    getKeyIV(password: string, method: string): KeyIV {
+        const m = method.toLowerCase() as CipherMethod;
+        const passwordBuf = Buffer.from(password, 'ascii');
+        const [keyLen, ivLen] = this.get_cipher_len(m);
+        const ref = EVP_BytesToKey(passwordBuf, keyLen, ivLen);
+        return { key: ref[0], iv: ref[1] };
+    }
+
+    encrypt(buf: Buffer): Buffer {
+        const cipher = crypto.createCipheriv(this.method, this._EVP_KEY, this._IV);
+        const encrypted = cipher.update(buf);
+        const result = cipher.final();
+        return Buffer.concat([encrypted, result]);
+    }
+
+    decrypt(buf: Buffer): Buffer {
+        const decipher = crypto.createDecipheriv(this.method, this._EVP_KEY, this._IV);
+        const decrypted = decipher.update(buf);
+        const result = decipher.final();
+        return Buffer.concat([decrypted, result]);
+    }
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+export { default as deferred } from './deferred';
+export type { Deferred } from './deferred';
+
+export * as encrypt from './encrypt';
+export type { CipherMethod } from './encrypt';
+
+export { default as logger } from './logger';
+export type { LogLevel, Logger } from './logger';
+
+export { default as md5 } from './md5';
+
+export { default as merge } from './merge';
+
+export * as proxy from './proxy';
+export type { OnConnect, ConnectCallback } from './proxy';
+
+export { default as retry } from './retry';
+export type { RetryOptions } from './retry';
+
+export * as server from './server';
+
+export * as socks5 from './socks5';
+export type { Socks5AddrInfo } from './socks5';
+
+export * as timeout from './timeout';
+
+export * as transport from './transport';
+
+export { default as uuid } from './uuid';

package/src/logger.ts

@@ -0,0 +1,59 @@
+export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'log' | 'debug';
+
+export interface Logger {
+    fatal: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+    info: (msg: string) => void;
+    log: (msg: string) => void;
+    debug: (msg: string) => void;
+}
+
+interface LevelConfig {
+    piv: number;
+    colour: string;
+}
+
+const levelVal: Record<LogLevel, LevelConfig> = {
+    fatal: { piv: 1, colour: '\x1b[31m%s\x1b[0m' },
+    error: { piv: 2, colour: '\x1b[31m%s\x1b[0m' },
+    warn: { piv: 3, colour: '\x1b[33m%s\x1b[0m' },
+    info: { piv: 4, colour: '\x1b[32m%s\x1b[0m' },
+    log: { piv: 5, colour: '\x1b[37m%s\x1b[0m' },
+    debug: { piv: 6, colour: '\x1b[35m%s\x1b[0m' },
+};
+
+function formatDate(date: Date): string {
+    const pad = (n: number) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}/${pad(date.getMonth() + 1)}/${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+export default function getCustomLogger(
+    label: string,
+    level: LogLevel,
+    _logFile?: string
+): Logger {
+    const noop = () => undefined;
+    const setPiv = levelVal[level].piv;
+
+    function makeLogFn(key: LogLevel): (msg: string) => void {
+        if (levelVal[key].piv <= setPiv) {
+            const colour = levelVal[key].colour;
+            return (msg: string) => {
+                const date = formatDate(new Date());
+                const prefix = `${date} [${key[0].toUpperCase()}] ${label} `;
+                console.log(colour, prefix, msg);
+            };
+        }
+        return noop;
+    }
+
+    return {
+        fatal: makeLogFn('fatal'),
+        error: makeLogFn('error'),
+        warn: makeLogFn('warn'),
+        info: makeLogFn('info'),
+        log: makeLogFn('log'),
+        debug: makeLogFn('debug'),
+    };
+}

package/src/md5.ts

@@ -0,0 +1,5 @@
+import crypto from 'crypto';
+
+export default function md5(s: string | number): string {
+    return crypto.createHash('md5').update(String(s)).digest('hex');
+}

package/src/merge.ts

@@ -0,0 +1,16 @@
+export default function merge<T extends Record<string, any>>(
+    target: T,
+    ...sources: (Record<string, any> | null | undefined)[]
+): T & Record<string, any> {
+    target = target || ({} as T);
+    sources.forEach((temp) => {
+        if (temp) {
+            Object.keys(temp).forEach((key) => {
+                if (temp[key] !== null && temp[key] !== undefined) {
+                    (target as Record<string, any>)[key] = temp[key];
+                }
+            });
+        }
+    });
+    return target;
+}

package/src/proxy.ts

@@ -0,0 +1,65 @@
+import net from 'net';
+import { buildSocks5Addr } from './socks5';
+
+export type ConnectCallback = (err?: Error | null) => void;
+export type OnConnect = (addr: Buffer, callback: ConnectCallback) => void;
+
+export function createSocks5Proxy(cSock: net.Socket, onConnect: OnConnect): void {
+    let stage = 'INIT';
+    cSock.on('data', function dataListener(data: Buffer) {
+        if (stage === 'INIT') {
+            cSock.write('\x05\x00');
+            stage = 'ADDR';
+            return;
+        } else if (stage === 'ADDR') {
+            onConnect(data.slice(3), (err) => {
+                if (!err) {
+                    stage = 'STREAM';
+                    cSock.write('\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00');
+                    cSock.removeAllListeners('data');
+                    cSock.pause();
+                } else {
+                    cSock.destroy();
+                }
+            });
+            return;
+        }
+    });
+
+    cSock.on('error', () => {
+        cSock.destroy();
+    });
+}
+
+export function createConnectProxy(cSock: net.Socket, onConnect: OnConnect): void {
+    let stage = 'INIT';
+    cSock.on('data', (data: Buffer) => {
+        if (stage === 'INIT') {
+            const str = data.toString('ascii');
+            const lines = str.split(/\s/g);
+            if (lines[0] !== 'CONNECT') {
+                cSock.destroy();
+                return;
+            }
+            const hoststr = lines[1];
+            const reqhost = hoststr.split(':');
+            const hostname = reqhost[0];
+            const port = Number(reqhost[1]);
+            const socksAddrInfo = buildSocks5Addr(hostname, port);
+            onConnect(socksAddrInfo, (err) => {
+                if (!err) {
+                    cSock.write(Buffer.from('HTTP/1.1 200 Connection Established\r\n\r\n'));
+                    stage = 'STREAM';
+                    cSock.removeAllListeners('data');
+                    cSock.pause();
+                } else {
+                    cSock.destroy();
+                }
+            });
+        }
+    });
+
+    cSock.on('error', () => {
+        cSock.destroy();
+    });
+}

package/src/retry.ts

@@ -0,0 +1,32 @@
+const delay = (time: number): Promise<void> =>
+    new Promise((resolve) => setTimeout(resolve, time));
+
+export interface RetryOptions {
+    times?: number;
+    interval?: number;
+}
+
+export default function retryPromise<T>(
+    fn: () => Promise<T>,
+    opts: RetryOptions = {},
+    errcall?: (err: Error) => void
+): Promise<T> {
+    const retryCount = opts.times !== undefined ? opts.times : 5;
+
+    function invoker(idx: number): Promise<T> {
+        if (idx >= retryCount) {
+            return Promise.reject(
+                new Error(`expect retryCount ${retryCount} is attached!`)
+            );
+        }
+        return fn().catch((err: Error) => {
+            errcall && errcall(err);
+            if (opts.interval) {
+                return delay(opts.interval).then(() => invoker(idx + 1));
+            } else {
+                return invoker(idx + 1);
+            }
+        });
+    }
+    return invoker(0);
+}

package/src/server.ts

@@ -0,0 +1,77 @@
+import net from 'net';
+import http from 'http';
+import tls from 'tls';
+import http2 from 'http2';
+import url from 'url';
+import WebSocket from 'ws';
+
+export type HttpHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export type WsHandler = (ws: WebSocket) => void;
+export type StreamHandler = (stream: net.Socket | http2.ServerHttp2Stream) => void;
+export type ConnHandler = (conn: net.Socket | tls.TLSSocket) => void;
+
+export function createWsServer(
+    workPath: string,
+    handler: WsHandler,
+    httpHandler?: HttpHandler
+): http.Server {
+    const server = http.createServer(function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    // ws 2.x exposes Server as WebSocket.Server
+    const WsServer = (WebSocket as any).Server as typeof WebSocket;
+    const wss: any = new (WsServer as any)({ noServer: true, clientTracking: false });
+    wss.on('connection', function (wsconn: WebSocket) {
+        handler(wsconn);
+    });
+    server.on('upgrade', function (request, socket, head) {
+        const pathname = url.parse(request.url || '').pathname;
+        if (pathname === workPath) {
+            wss.handleUpgrade(request, socket as net.Socket, head, function done(ws: WebSocket) {
+                wss.emit('connection', ws, request);
+            });
+        } else {
+            socket.destroy();
+        }
+    });
+    return server;
+}
+
+export function createHttp2Server(
+    tlsOpts: tls.TlsOptions,
+    workPath: string,
+    handler: (stream: http2.ServerHttp2Stream) => void,
+    httpHandler?: (req: http2.Http2ServerRequest, res: http2.Http2ServerResponse) => void
+): http2.Http2SecureServer {
+    const http2Opts = Object.assign({ allowHTTP1: true }, tlsOpts);
+    const server = http2.createSecureServer(http2Opts, function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    server.on('stream', function (stream: http2.ServerHttp2Stream, headers: http2.IncomingHttpHeaders) {
+        const path = headers[':path'];
+        if (path === workPath) {
+            handler(stream);
+        } else {
+            stream.destroy();
+        }
+    });
+    return server;
+}
+
+export function createTcpServer(handler: ConnHandler): net.Server {
+    const server = net.createServer(function (conn) {
+        handler(conn);
+    });
+    return server;
+}
+
+export function createTlsServer(tlsOpts: tls.TlsOptions, handler: ConnHandler): tls.Server {
+    const server = tls.createServer(tlsOpts, function (conn) {
+        handler(conn);
+    });
+    return server;
+}

package/src/socks5.ts

@@ -0,0 +1,46 @@
+export interface Socks5AddrInfo {
+    dstAddr: string;
+    dstPort: number;
+}
+
+export function parseSocks5Addr(buf: Buffer, offset = 0): Socks5AddrInfo {
+    if (offset > 0) {
+        buf = buf.slice(offset);
+    }
+    const type = buf.readUInt8(0);
+    const addrData = buf.slice(1);
+    let dstAddr = '';
+    let dstPort = 0;
+
+    if (type === 0x01) {
+        const IP = addrData.slice(0, -2);
+        const PORT = addrData.slice(-2);
+        dstAddr = Array.from(IP)
+            .map((temp) => Number(temp).toString(10))
+            .join('.');
+        dstPort = PORT[0] * 256 + PORT[1];
+    } else if (type === 0x03) {
+        const addrLen = addrData.readUInt8(0);
+        const domain = addrData.slice(1, addrLen + 1);
+        const port = addrData.slice(addrLen + 1);
+        dstAddr = domain.toString();
+        dstPort = port[0] * 256 + port[1];
+    }
+    return { dstAddr, dstPort };
+}
+
+export function buildSocks5Addr(hostname: string, port: number): Buffer {
+    if (/^(\d+\.){3}\d+$/.test(hostname)) {
+        const parts = hostname.split('.').map((p) => Number(p));
+        const portBuf = Buffer.from([Math.floor(port / 256), port % 256]);
+        const preBuf = Buffer.from([0x01, parts[0], parts[1], parts[2], parts[3]]);
+        return Buffer.concat([preBuf, portBuf]);
+    } else {
+        const preBuf = Buffer.from([0x03, hostname.length]);
+        const domainBuf = Buffer.from(hostname);
+        const portBuf = Buffer.from([Math.floor(port / 256), port % 256]);
+        return Buffer.concat([preBuf, domainBuf, portBuf]);
+    }
+}
+
+export const parseAddrInfo = parseSocks5Addr;

package/src/timeout.ts

@@ -0,0 +1,3 @@
+export function timeoutPromise(time: number): Promise<string> {
+    return new Promise((resolve) => setTimeout(() => resolve('timeout:' + time), time));
+}