ddan-js 2.8.0 → 2.8.2

package/bin/lib/modules/hook/base.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = require("../../util/is");
-async function to(promise, errorExt) {
+async function to(promise, errorExt, fn) {
     return promise
-        .then((data) => [null, data])
+        .then((data) => {
+        fn && fn();
+        return [null, data];
+    })
         .catch((err) => {
         if (errorExt) {
             Object.assign(err, errorExt);
         }
+        fn && fn();
         return [err, undefined];
     });
 }
@@ -17,7 +21,7 @@ async function to(promise, errorExt) {
  * @returns
  */
 const delay = (ms = 1000) => new Promise((resolve) => setTimeout(resolve, ms));
-const safeRun = (func) => {
+const safeRun = (func, fn) => {
     try {
         let temp;
         if (is_1.default.isFunction(func)) {
@@ -27,11 +31,30 @@ const safeRun = (func) => {
             temp = func;
         }
         // promise = is.isPromise(temp) ? temp : Promise.resolve(temp);
-        return to(Promise.resolve(temp));
+        return to(Promise.resolve(temp), undefined, fn);
     }
     catch (err) {
+        fn && fn();
         return Promise.resolve([err, undefined]);
     }
 };
-const go = (task) => safeRun(task);
-exports.default = { to, go, delay, safeRun };
+const go = (task, fn) => safeRun(task, fn);
+const toError = (value) => {
+    value = typeof value === 'function' ? value() : value;
+    return typeof value === 'string' ? new Error(value) : value;
+};
+const timeout = (task, ms = 0, desc = 'timeout') => {
+    if (ms <= 0) {
+        return safeRun(task);
+    }
+    let timerid;
+    function clear() {
+        timerid && clearTimeout(timerid);
+    }
+    const fn = new Promise((resolve) => {
+        clear();
+        timerid = setTimeout(() => resolve([toError(desc || 'timeout'), undefined]), ms);
+    });
+    return Promise.race([safeRun(task, clear), fn]);
+};
+exports.default = { to, go, delay, safeRun, toError, timeout };

package/bin/lib/modules/hook/log.js

@@ -3,8 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = require("../../util/is");
 const rsa_web_1 = require("../node/rsa-web");
 const rsa_1 = require("../rsa");
+const tea_1 = require("../crypto/tea");
+const convert_1 = require("../convert");
 const string_1 = require("../string");
-const logString = async (data) => {
+const logString = (data) => {
+    try {
+        const jsonString = JSON.stringify(data);
+        if (jsonString === undefined)
+            return '';
+        return tea_1.default.encode(jsonString, convert_1.default.hex2str(tea_1.default.TEAKey));
+    }
+    catch (error) {
+        return '';
+    }
+};
+const logParse = (logStr) => {
+    try {
+        if (!logStr)
+            return '';
+        const ret = tea_1.default.decode(logStr, convert_1.default.hex2str(tea_1.default.TEAKey));
+        return string_1.default.jsonFormat(ret);
+    }
+    catch (error) {
+        return '';
+    }
+};
+const logRString = async (data) => {
     try {
         const jsonString = JSON.stringify(data);
         if (jsonString === undefined)
@@ -16,7 +40,7 @@ const logString = async (data) => {
         return '';
     }
 };
-const logParse = async (logStr) => {
+const logRParse = async (logStr) => {
     try {
         if (!logStr)
             return '';
@@ -27,4 +51,4 @@ const logParse = async (logStr) => {
         return '';
     }
 };
-exports.default = { logString, logParse };
+exports.default = { logString, logParse, logRString, logRParse };

package/bin/lib/modules/math/index.js

@@ -69,36 +69,40 @@ function radian2degree(radians) {
 function degree2radian(degrees) {
     return degrees / radiansToAngles;
 }
-function formatMemory(mem) {
-    let _mem = mem;
+function calcDataSize(data) {
     const result = {
-        g: 0,
-        m: 0,
+        gb: 0,
+        mb: 0,
         kb: 0,
         b: 0,
+        total: data,
         desc: '',
     };
-    if (_mem >= 1 << 30) {
-        result.g = Math.floor(_mem / (1 << 30));
-        _mem = _mem % (1 << 30);
+    const units = [
+        { name: 'gb', divisor: 1 << 30 },
+        { name: 'mb', divisor: 1 << 20 },
+        { name: 'kb', divisor: 1 << 10 },
+        { name: 'b', divisor: 1 },
+    ];
+    // 计算每个单位的数量
+    for (const unit of units) {
+        const value = Math.floor(data / unit.divisor);
+        result[unit.name] = value;
+        data -= value * unit.divisor;
     }
-    if (_mem >= 1 << 20) {
-        result.m = Math.floor(_mem / (1 << 20));
-        _mem = _mem % (1 << 20);
+    // 计算简洁的描述
+    if (result.gb > 0) {
+        result.desc = (result.gb + result.mb / 1024).toFixed(2) + 'GB';
     }
-    if (_mem >= 1 << 10) {
-        result.kb = Math.floor(_mem / (1 << 10));
-        _mem = _mem % (1 << 10);
+    else if (result.mb > 0) {
+        result.desc = (result.mb + result.kb / 1024).toFixed(2) + 'MB';
+    }
+    else if (result.kb > 0) {
+        result.desc = (result.kb + result.b / 1024).toFixed(2) + 'KB';
+    }
+    else {
+        result.desc = result.b + 'B';
     }
-    result.b = _mem;
-    if (mem >= 1 << 30)
-        result.desc = (mem / (1 << 30)).toFixed(2) + 'G';
-    else if (mem >= 1 << 20)
-        result.desc = (mem / (1 << 20)).toFixed(2) + 'M';
-    else if (mem >= 1 << 10)
-        result.desc = (mem / (1 << 10)).toFixed(2) + 'KB';
-    else
-        result.desc = mem + 'B';
     return result;
 }
 exports.default = {
@@ -110,5 +114,5 @@ exports.default = {
     float,
     radian2degree,
     degree2radian,
-    formatMemory,
+    calcDataSize,
 };

package/bin/lib/modules/node/socks5.js

@@ -23,6 +23,8 @@ class Socks5 {
     __event;
     __pipeline;
     __logger;
+    __totalReceived = 0;
+    __totalSent = 0;
     constructor(upstreamProxy, allowedDomains = ['*'], debug = false, logger) {
         this.__event = new event_1.default();
         this.upstreamProxy = upstreamProxy;
@@ -43,6 +45,12 @@ class Socks5 {
             return '';
         return `socks5://127.0.0.1:${this.__port}`;
     }
+    get totalReceived() {
+        return this.__totalReceived;
+    }
+    get totalSent() {
+        return this.__totalSent;
+    }
     validateProxyConfig(proxyConfig = this.upstreamProxy) {
         const { ipaddress, port, userId, password } = proxyConfig || {};
         if (!ipaddress || typeof ipaddress !== 'string') {
@@ -146,19 +154,19 @@ class Socks5 {
                 // 走上游代理
                 const upstreamSocket = await this.connectToUpstreamProxy(destination);
                 this.__logger?.info(`[socks5] handle connection upstream`, addrport);
-                this.setupDataForwarding(clientSocket, upstreamSocket);
+                this.setupDataForwarding(clientSocket, upstreamSocket, 'upstream');
             }
             else if (this.useSystemProxy && this.systemProxy && !index_1.default.isLocalIpAddress(addr)) {
                 // 走系统代理
                 const systemSocket = await this.connectToSystemProxy(destination);
                 this.__debug && console.info(`[socks5] handle connection system`, addrport);
-                this.setupDataForwarding(clientSocket, systemSocket);
+                this.setupDataForwarding(clientSocket, systemSocket, 'system');
             }
             else {
                 this.__debug && console.info(`[socks5] handle connection local`, addrport);
                 // 本地连接
                 const localSocket = await this.connectToLocal(destination);
-                this.setupDataForwarding(clientSocket, localSocket);
+                this.setupDataForwarding(clientSocket, localSocket, 'local');
             }
         }
         catch (err) {
@@ -281,12 +289,20 @@ class Socks5 {
             });
         });
     }
-    setupDataForwarding(clientSocket, targetSocket) {
+    setupDataForwarding(clientSocket, targetSocket, type = 'local') {
         clientSocket.write(new Uint8Array([0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
         clientSocket.pipe(targetSocket);
         targetSocket.pipe(clientSocket);
         const addrPort = `${targetSocket.localAddress}:${targetSocket.localPort}`;
         this.__debug && console.info(`[socks5] setupDataForwarding ${addrPort}`);
+        if (type === 'upstream') {
+            targetSocket.on('data', (buf) => {
+                this.__totalSent += buf.length;
+            });
+            clientSocket.on('data', (buf) => {
+                this.__totalReceived += buf.length;
+            });
+        }
         clientSocket.on('close', () => {
             this.__debug && console.info('[socks5] client socket close', addrPort);
             targetSocket.end();
@@ -348,6 +364,10 @@ class Socks5 {
             return;
         this.__event.off(name, listener);
     }
+    resetStatistics() {
+        this.__totalReceived = 0;
+        this.__totalSent = 0;
+    }
     _emit(name, ...args) {
         try {
             if (!name)

package/bin/types/class/kvalue.d.ts

@@ -7,4 +7,5 @@ export default class KValue<T = any> {
     get value(): T | undefined;
     set(value?: T): void;
     updateAt(): void;
+    clear(): void;
 }

package/bin/types/index.d.ts

@@ -64,6 +64,7 @@ declare const dUtil: {
         encodeByOss: (input: string) => string;
     };
     tea: {
+        TEAKey: string;
         encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
         decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
         toTeaKey: (str: string) => Uint32Array;
@@ -124,11 +125,12 @@ declare const dUtil: {
         }) => number;
         radian2degree: (radians: number) => number;
         degree2radian: (degrees: number) => number;
-        formatMemory: (mem: number) => {
-            g: number;
-            m: number;
+        calcDataSize: (data: number) => {
+            gb: number;
+            mb: number;
             kb: number;
             b: number;
+            total: number;
             desc: string;
         };
     };
@@ -285,6 +287,25 @@ declare const dHook: {
         readonly Instance: T;
         readonly I: T;
     };
+    random: (max: number) => number;
+    randomRange: (min: number, max: number) => number;
+    lerp: (start: number, end: number, t: number) => number;
+    randoms: (max: number, count?: number, repeat?: boolean) => number[];
+    strip: (num: string | number, digits?: number) => number;
+    float: (num: string | number, { digits, fixed }?: {
+        digits?: number | undefined;
+        fixed?: boolean | undefined;
+    }) => number;
+    radian2degree: (radians: number) => number;
+    degree2radian: (degrees: number) => number;
+    calcDataSize: (data: number) => {
+        gb: number;
+        mb: number;
+        kb: number;
+        b: number;
+        total: number;
+        desc: string;
+    };
     toString: (value: any) => any;
     startCase: (string: any) => any;
     snakeCase: (string: any) => any;
@@ -312,18 +333,23 @@ declare const dHook: {
     pipe: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/pipeline").default;
     pipeline: (max?: number) => import("./modules/hook/modules/pipeline").default;
     safeTask: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/safeTask").default;
-    logString: (data: any) => Promise<string>;
-    logParse: (logStr: string) => Promise<string>;
-    to: <T_2 = any, U extends object = any>(promise: Promise<T_2>, errorExt?: object | undefined) => Promise<[null, T_2] | [U, undefined]>;
-    go: <T_3 = any>(task?: import("./typings").Ddan.PFunction<T_3> | undefined) => Promise<[any, undefined] | [null, T_3]>;
+    logString: (data: any) => string;
+    logParse: (logStr: string) => string;
+    logRString: (data: any) => Promise<string>;
+    logRParse: (logStr: string) => Promise<string>;
+    to: <T_2 = any, U extends object = any>(promise: Promise<T_2>, errorExt?: object | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[null, T_2] | [U, undefined]>;
+    go: <T_3 = any>(task?: import("./typings").Ddan.PFunction<T_3> | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_3]>;
     delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_4 = any>(func: any) => Promise<[any, undefined] | [null, T_4]>;
+    safeRun: <T_4 = any>(func: any, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_4]>;
+    toError: (value: any) => any;
+    timeout: <T_5 = any>(task?: import("./typings").Ddan.PFunction<T_5> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_5]>;
     base64: {
         encode: (input: string) => string;
         decode: (base64Str: string) => string;
         encodeByOss: (input: string) => string;
     };
     tea: {
+        TEAKey: string;
         encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
         decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
         toTeaKey: (str: string) => Uint32Array;
@@ -650,7 +676,7 @@ declare const dNode: {
     brotliCompress: typeof import("./modules/node/brotli").brotliCompress;
     brotliDecompress: typeof import("./modules/node/brotli").brotliDecompress;
 };
-export { dUtil, dHook, dWeb, dMini, dCdn, dStore, dJoker, dTracker, dLogger, dNode, KValue, Mapping };
+export { dUtil, dHook, dWeb, dMini, dCdn, dStore, dJoker, dTracker, dLogger, dNode, Event, KValue, Mapping };
 declare const _default: {
     gbk: {
         gbkLength: (str: string) => number;
@@ -691,12 +717,16 @@ declare const _default: {
         pipe: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/pipeline").default;
         pipeline: (max?: number) => import("./modules/hook/modules/pipeline").default;
         safeTask: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/safeTask").default;
-        logString: (data: any) => Promise<string>;
-        logParse: (logStr: string) => Promise<string>;
-        to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
-        go: <T_2 = any>(task?: import("./typings").Ddan.PFunction<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
+        logString: (data: any) => string;
+        logParse: (logStr: string) => string;
+        logRString: (data: any) => Promise<string>;
+        logRParse: (logStr: string) => Promise<string>;
+        to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[null, T_1] | [U, undefined]>;
+        go: <T_2 = any>(task?: import("./typings").Ddan.PFunction<T_2> | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_2]>;
         delay: (ms?: number) => Promise<unknown>;
-        safeRun: <T_3 = any>(func: any) => Promise<[any, undefined] | [null, T_3]>;
+        safeRun: <T_3 = any>(func: any, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_3]>;
+        toError: (value: any) => any;
+        timeout: <T_4 = any>(task?: import("./typings").Ddan.PFunction<T_4> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_4]>;
     };
     math: {
         random: (max: number) => number;
@@ -710,24 +740,25 @@ declare const _default: {
         }) => number;
         radian2degree: (radians: number) => number;
         degree2radian: (degrees: number) => number;
-        formatMemory: (mem: number) => {
-            g: number;
-            m: number;
+        calcDataSize: (data: number) => {
+            gb: number;
+            mb: number;
             kb: number;
             b: number;
+            total: number;
             desc: string;
         };
     };
     util: {
         includes: typeof import("./util/includes").default;
         forof: (source: any, cb: (key: any, val: any) => void) => void;
-        singleton: <T_4>() => {
+        singleton: <T_5>() => {
             new (): {};
             __instance__: any;
-            readonly Instance: T_4;
-            readonly I: T_4;
+            readonly Instance: T_5;
+            readonly I: T_5;
         };
-        getset: <T_5 = any>(t?: T_5 | undefined) => import("./typings").Ddan.IGetset<T_5>;
+        getset: <T_6 = any>(t?: T_6 | undefined) => import("./typings").Ddan.IGetset<T_6>;
         copy: (source: any, options?: {
             fields?: string[] | undefined;
             camel?: boolean | undefined;
@@ -740,7 +771,7 @@ declare const _default: {
             number?: boolean | undefined;
             boolean?: boolean | undefined;
         }) => any;
-        cloneClass: <T_6>(source: T_6) => T_6;
+        cloneClass: <T_7>(source: T_7) => T_7;
         combine: (target: any, source: any, options?: import("./typings").Ddan.IIgnoreParams) => any;
         combines: (objs: any[], options?: import("./typings").Ddan.IIgnoreParams) => {};
         observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
@@ -772,16 +803,16 @@ declare const _default: {
         isArrayBuffer: (data: any) => boolean;
     };
     list: {
-        stepAction: <T_7>(list: T_7[], func: import("./typings").Ddan.Task<T_7, void>, stepCount?: number) => void;
-        skip: <T_8>(list: T_8[], count: number) => T_8[];
-        take: <T_9>(list: T_9[], count: number, skip?: number) => T_9[];
-        distinct: <T_10>(list: T_10[]) => T_10[];
-        randoms: <T_11>(list: T_11[], count?: number, repeat?: boolean) => T_11[];
+        stepAction: <T_8>(list: T_8[], func: import("./typings").Ddan.Task<T_8, void>, stepCount?: number) => void;
+        skip: <T_9>(list: T_9[], count: number) => T_9[];
+        take: <T_10>(list: T_10[], count: number, skip?: number) => T_10[];
+        distinct: <T_11>(list: T_11[]) => T_11[];
+        randoms: <T_12>(list: T_12[], count?: number, repeat?: boolean) => T_12[];
         toKV: (list: import("./typings").Ddan.KV<any>[], key: string, value: string) => import("./typings").Ddan.KV<any>;
-        groupBy: <T_12>(list: T_12[], key: string) => Record<string, T_12[]>;
-        first: <T_13>(list: T_13[]) => T_13 | undefined;
-        last: <T_14>(list: T_14[]) => T_14 | undefined;
-        toList: <T_15>(val: T_15 | T_15[]) => T_15[];
+        groupBy: <T_13>(list: T_13[], key: string) => Record<string, T_13[]>;
+        first: <T_14>(list: T_14[]) => T_14 | undefined;
+        last: <T_15>(list: T_15[]) => T_15 | undefined;
+        toList: <T_16>(val: T_16 | T_16[]) => T_16[];
     };
     string: {
         toString: (value: any) => any;
@@ -814,7 +845,7 @@ declare const _default: {
             number?: boolean | undefined;
             boolean?: boolean | undefined;
         }) => any;
-        cloneClass: <T_6>(source: T_6) => T_6;
+        cloneClass: <T_7>(source: T_7) => T_7;
         combine: (target: any, source: any, options?: import("./typings").Ddan.IIgnoreParams) => any;
         combines: (objs: any[], options?: import("./typings").Ddan.IIgnoreParams) => {};
         observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
@@ -827,6 +858,7 @@ declare const _default: {
             encodeByOss: (input: string) => string;
         };
         tea: {
+            TEAKey: string;
             encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
             decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
             toTeaKey: (str: string) => Uint32Array;

package/bin/types/modules/crypto/index.d.ts

@@ -5,6 +5,7 @@ declare const _default: {
         encodeByOss: (input: string) => string;
     };
     tea: {
+        TEAKey: string;
         encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
         decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
         toTeaKey: (str: string) => Uint32Array;

package/bin/types/modules/crypto/tea.d.ts

@@ -1,4 +1,5 @@
 declare const _default: {
+    TEAKey: string;
     encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
     decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
     toTeaKey: (str: string) => Uint32Array;

package/bin/types/modules/hook/base.d.ts

@@ -1,9 +1,11 @@
 import { Ddan } from '../../typings';
-declare function to<T = any, U extends object = any>(promise: Promise<T>, errorExt?: object): Promise<[null, T] | [U, undefined]>;
+declare function to<T = any, U extends object = any>(promise: Promise<T>, errorExt?: object, fn?: Ddan.noop): Promise<[null, T] | [U, undefined]>;
 declare const _default: {
     to: typeof to;
-    go: <T = any>(task?: Ddan.PFunction<T> | undefined) => Promise<[any, undefined] | [null, T]>;
+    go: <T = any>(task?: Ddan.PFunction<T> | undefined, fn?: Ddan.noop | undefined) => Promise<[any, undefined] | [null, T]>;
     delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_1 = any>(func: any) => Promise<[null, T_1] | [any, undefined]>;
+    safeRun: <T_1 = any>(func: any, fn?: Ddan.noop | undefined) => Promise<[null, T_1] | [any, undefined]>;
+    toError: (value: any) => any;
+    timeout: <T_2 = any>(task?: Ddan.PFunction<T_2> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_2]>;
 };
 export default _default;

package/bin/types/modules/hook/index.d.ts

@@ -25,11 +25,15 @@ declare const _default: {
     pipe: (func: Ddan.Function, callback?: ((result: Ddan.SafeResult<any>) => void) | undefined) => DPipeline;
     pipeline: (max?: number) => DPipeline;
     safeTask: (func: Ddan.Function, callback?: ((result: Ddan.SafeResult<any>) => void) | undefined) => DSafeTask;
-    logString: (data: any) => Promise<string>;
-    logParse: (logStr: string) => Promise<string>;
-    to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
-    go: <T_1 = any>(task?: Ddan.PFunction<T_1> | undefined) => Promise<[any, undefined] | [null, T_1]>;
+    logString: (data: any) => string;
+    logParse: (logStr: string) => string;
+    logRString: (data: any) => Promise<string>;
+    logRParse: (logStr: string) => Promise<string>;
+    to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined, fn?: Ddan.noop | undefined) => Promise<[null, T] | [U, undefined]>;
+    go: <T_1 = any>(task?: Ddan.PFunction<T_1> | undefined, fn?: Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_1]>;
     delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_2 = any>(func: any) => Promise<[null, T_2] | [any, undefined]>;
+    safeRun: <T_2 = any>(func: any, fn?: Ddan.noop | undefined) => Promise<[null, T_2] | [any, undefined]>;
+    toError: (value: any) => any;
+    timeout: <T_3 = any>(task?: Ddan.PFunction<T_3> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_3]>;
 };
 export default _default;

package/bin/types/modules/hook/log.d.ts

@@ -1,5 +1,7 @@
 declare const _default: {
-    logString: (data: any) => Promise<string>;
-    logParse: (logStr: string) => Promise<string>;
+    logString: (data: any) => string;
+    logParse: (logStr: string) => string;
+    logRString: (data: any) => Promise<string>;
+    logRParse: (logStr: string) => Promise<string>;
 };
 export default _default;

package/bin/types/modules/math/index.d.ts

@@ -34,11 +34,12 @@ declare function radian2degree(radians: number): number;
  * @returns
  */
 declare function degree2radian(degrees: number): number;
-declare function formatMemory(mem: number): {
-    g: number;
-    m: number;
+declare function calcDataSize(data: number): {
+    gb: number;
+    mb: number;
     kb: number;
     b: number;
+    total: number;
     desc: string;
 };
 declare const _default: {
@@ -50,6 +51,6 @@ declare const _default: {
     float: typeof float;
     radian2degree: typeof radian2degree;
     degree2radian: typeof degree2radian;
-    formatMemory: typeof formatMemory;
+    calcDataSize: typeof calcDataSize;
 };
 export default _default;

package/bin/types/modules/node/socks5.d.ts

@@ -30,10 +30,14 @@ export declare class Socks5 {
     __event: DEvent;
     __pipeline: DPipeline;
     __logger: ILogger;
+    __totalReceived: number;
+    __totalSent: number;
     constructor(upstreamProxy: IProxyConfig, allowedDomains?: string[] | ['*'], debug?: boolean, logger?: ILogger);
     get id(): string;
     get port(): number;
     get url(): string;
+    get totalReceived(): number;
+    get totalSent(): number;
     validateProxyConfig(proxyConfig?: IProxyConfig): "" | "无效的上游代理 IP 地址" | "无效的上游代理端口" | "无效的上游代理用户名" | "无效的上游代理密码";
     start(startPort?: number): Promise<number>;
     setUpstreamProxy(upstreamProxy: IProxyConfig): boolean;
@@ -83,6 +87,7 @@ export declare class Socks5 {
     close(): void;
     on(name: Socks5EventType, listener: (...args: any[]) => void): void;
     off(name: Socks5EventType, listener: (...args: any[]) => void): void;
+    resetStatistics(): void;
     private _emit;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "",
   "keywords": [
     "ddan-js",