ddan-js 2.7.10 → 2.8.1

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("../../util/is");
+const bytes2str = (bytes) => {
+    if (!bytes || !is_1.default.isArrayLike(bytes))
+        return '';
+    const str = bytes.reduce((str, byte) => str + String.fromCharCode(byte), '');
+    return str;
+};
+const str2bytes = (str = '') => {
+    const content = str;
+    const bufView = new Uint8Array(content.length);
+    for (let i = 0, strLen = content.length; i < strLen; i++) {
+        bufView[i] = content.charCodeAt(i);
+    }
+    return bufView;
+};
+const str2hex = (str) => {
+    let hexString = '';
+    for (let i = 0; i < str.length; i++) {
+        hexString += str.charCodeAt(i).toString(16).padStart(2, '0');
+    }
+    return hexString;
+};
+const hex2str = (hexstr) => {
+    let str = '';
+    for (let i = 0; i < hexstr.length; i += 2) {
+        str += String.fromCharCode(parseInt(hexstr.substr(i, 2), 16));
+    }
+    return str;
+};
+const concatBytes = (...args) => {
+    // 计算所有 Uint8Array 的总长度
+    const totalLength = args.reduce((sum, arr) => sum + arr.length, 0);
+    // 创建一个新的 Uint8Array
+    const combined = new Uint8Array(totalLength);
+    // 当前写入的位置
+    let offset = 0;
+    // 将每个 Uint8Array 复制到新的数组中
+    for (const arr of args) {
+        combined.set(arr, offset);
+        offset += arr.length;
+    }
+    return combined;
+};
+const uint32ToBytes = (uint32) => {
+    const bytes = new Uint8Array(8);
+    bytes[0] = (uint32[0] >>> 24) & 0xff;
+    bytes[1] = (uint32[0] >>> 16) & 0xff;
+    bytes[2] = (uint32[0] >>> 8) & 0xff;
+    bytes[3] = uint32[0] & 0xff;
+    bytes[4] = (uint32[1] >>> 24) & 0xff;
+    bytes[5] = (uint32[1] >>> 16) & 0xff;
+    bytes[6] = (uint32[1] >>> 8) & 0xff;
+    bytes[7] = uint32[1] & 0xff;
+    return bytes;
+};
+const bytesToUint32 = (bytes) => {
+    const unit32 = new Uint32Array(2);
+    unit32[0] = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
+    unit32[1] = (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7];
+    return unit32;
+};
+const toUint32 = (str) => {
+    const length = Math.ceil(str.length / 4);
+    const uint32Array = new Uint32Array(length);
+    for (let i = 0; i < length; i++) {
+        uint32Array[i] =
+            (str.charCodeAt(i * 4) << 24) |
+                (str.charCodeAt(i * 4 + 1) << 16) |
+                (str.charCodeAt(i * 4 + 2) << 8) |
+                str.charCodeAt(i * 4 + 3);
+    }
+    return uint32Array;
+};
+const fromUint32 = (uint32) => {
+    let result = '';
+    for (let i = 0; i < uint32.length; i++) {
+        result += String.fromCharCode((uint32[i] >>> 24) & 0xff, // 提取最高 8 位
+        (uint32[i] >>> 16) & 0xff, // 提取次高 8 位
+        (uint32[i] >>> 8) & 0xff, // 提取次低 8 位
+        uint32[i] & 0xff // 提取最低 8 位
+        );
+    }
+    // 去掉可能因字符串长度不是4的倍数导致的填充字符
+    return result.replace(/\0+$/, '');
+};
+const hex2bytes = (hex) => {
+    let bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return bytes;
+};
+const bytes2hex = (bytes) => {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+};
+exports.default = {
+    bytes2str,
+    str2bytes,
+    str2hex,
+    hex2str,
+    concatBytes,
+    uint32ToBytes,
+    bytesToUint32,
+    hex2bytes,
+    bytes2hex,
+    toUint32,
+    fromUint32,
+};

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

@@ -4,6 +4,8 @@ const base64_1 = require("./base64");
 const is_1 = require("../../util/is");
 const utf8_1 = require("./utf8");
 const math_1 = require("../math");
+const base_1 = require("./base");
+const pkcs_1 = require("./pkcs");
 const str2ab = (content = '', base64 = false) => {
     if (base64) {
         return base64_1.default.base64ToBytes(content).buffer;
@@ -26,34 +28,6 @@ const ab2str = (data, base64 = false) => {
         return uint8Array.reduce((str, byte) => str + String.fromCharCode(byte), '');
     }
 };
-const bytesToStr = (bytes) => {
-    if (!bytes || !is_1.default.isArrayLike(bytes))
-        return '';
-    const str = bytes.reduce((str, byte) => str + String.fromCharCode(byte), '');
-    return str;
-};
-const strToBytes = (str = '') => {
-    const content = str;
-    const bufView = new Uint8Array(content.length);
-    for (let i = 0, strLen = content.length; i < strLen; i++) {
-        bufView[i] = content.charCodeAt(i);
-    }
-    return bufView;
-};
-const str2Hex = (str) => {
-    let hexString = '';
-    for (let i = 0; i < str.length; i++) {
-        hexString += str.charCodeAt(i).toString(16).padStart(2, '0');
-    }
-    return hexString;
-};
-const hex2Str = (hexstr) => {
-    let str = '';
-    for (let i = 0; i < hexstr.length; i += 2) {
-        str += String.fromCharCode(parseInt(hexstr.substr(i, 2), 16));
-    }
-    return str;
-};
 const utf8ToBase64 = (str) => {
     if (is_1.default.isBrowser) {
         return btoa(str);
@@ -107,34 +81,17 @@ const toDataUrl = (textOrBuf, contentType = 'text/plain') => {
     }
     return '';
 };
-const concatBytes = (...args) => {
-    // 计算所有 Uint8Array 的总长度
-    const totalLength = args.reduce((sum, arr) => sum + arr.length, 0);
-    // 创建一个新的 Uint8Array
-    const combined = new Uint8Array(totalLength);
-    // 当前写入的位置
-    let offset = 0;
-    // 将每个 Uint8Array 复制到新的数组中
-    for (const arr of args) {
-        combined.set(arr, offset);
-        offset += arr.length;
-    }
-    return combined;
-};
 exports.default = {
+    ...base_1.default,
+    ...pkcs_1.default,
     ...utf8_1.default,
     ...base64_1.default,
-    str2Hex,
-    hex2Str,
     str2ab,
     ab2str,
-    bytesToStr,
-    strToBytes,
     utf8ToBase64,
     base64ToUtf8,
     getRandomBytes,
     textEncode,
     textDecode,
     toDataUrl,
-    concatBytes,
 };

package/bin/lib/modules/convert/pkcs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("./base");
+// PKCS#7 填充函数，将明文填充到指定的块大小（8 字节）
+const pkcs7Padding = (plaintext, blockSize) => {
+    const padding = blockSize - (plaintext.length % blockSize);
+    const padtext = new Uint8Array(padding).fill(padding);
+    const result = base_1.default.concatBytes(plaintext, padtext);
+    return result;
+};
+// PKCS#7 去除填充函数，解密后去掉填充字符
+const pkcs7Unpadding = (ciphertext) => {
+    const padding = ciphertext[ciphertext.length - 1];
+    return ciphertext.slice(0, -padding);
+};
+exports.default = { pkcs7Padding, pkcs7Unpadding };

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

@@ -4,6 +4,7 @@ const time_1 = require("../time");
 const base64_1 = require("./base64");
 const const_1 = require("./const");
 const uuid_1 = require("./uuid");
+const tea_1 = require("./tea");
 const guid = (len, prefix = false, sep = "") => {
     const pwd = (0, uuid_1.default)(len || 32);
     if (!prefix)
@@ -22,6 +23,7 @@ const getHexString = (len) => {
 exports.default = {
     ...const_1.default,
     base64: base64_1.default,
+    tea: tea_1.default,
     uuid: uuid_1.default,
     guid,
     getHexString

package/bin/lib/modules/crypto/tea.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert_1 = require("../convert");
+const delta = 0x9e3779b9; // 常量 Delta
+const TEAKey = "33576f37387276645054657a6831686e454664424e5652456f47794835795942";
+const encrypt = (v, teaKey) => {
+    let sum = 0;
+    const n = 32; // 32轮加密
+    for (let i = 0; i < n; i++) {
+        sum = (sum + delta) >>> 0;
+        v[0] = (v[0] + (((v[1] << 4) + teaKey[0]) ^ (v[1] + sum) ^ ((v[1] >>> 5) + teaKey[1]))) >>> 0;
+        v[1] = (v[1] + (((v[0] << 4) + teaKey[2]) ^ (v[0] + sum) ^ ((v[0] >>> 5) + teaKey[3]))) >>> 0;
+    }
+    return v;
+};
+const decrypt = (v, teaKey) => {
+    const n = 32; // 32轮解密
+    let sum = (delta * n) >>> 0;
+    for (let i = 0; i < n; i++) {
+        v[1] = (v[1] - (((v[0] << 4) + teaKey[2]) ^ (v[0] + sum) ^ ((v[0] >>> 5) + teaKey[3]))) >>> 0;
+        v[0] = (v[0] - (((v[1] << 4) + teaKey[0]) ^ (v[1] + sum) ^ ((v[1] >>> 5) + teaKey[1]))) >>> 0;
+        sum = (sum - delta) >>> 0;
+    }
+    return v;
+};
+/**
+ * TEA KEY
+ * @param str 位
+ * @returns 4组32位
+ */
+const toTeaKey = (str) => {
+    const keyBytes = convert_1.default.str2bytes(str);
+    const key = new Uint32Array(4);
+    key[0] = (keyBytes[0] << 24) | (keyBytes[1] << 16) | (keyBytes[2] << 8) | keyBytes[3];
+    key[1] = (keyBytes[4] << 24) | (keyBytes[5] << 16) | (keyBytes[6] << 8) | keyBytes[7];
+    key[2] = (keyBytes[8] << 24) | (keyBytes[9] << 16) | (keyBytes[10] << 8) | keyBytes[11];
+    key[3] = (keyBytes[12] << 24) | (keyBytes[13] << 16) | (keyBytes[14] << 8) | keyBytes[15];
+    return key;
+};
+const encodeBytes = (plainbytes, key) => {
+    // 转换明文为字节数组并进行PKCS#7填充
+    const padded = convert_1.default.pkcs7Padding(plainbytes, 8);
+    // 将明文分块并加密
+    const key4LongBytes = toTeaKey(key);
+    const encryptedBlocks = [];
+    for (let i = 0; i < padded.length; i += 8) {
+        const block = convert_1.default.bytesToUint32(padded.slice(i, i + 8));
+        const encryptedBlock = encrypt(block, key4LongBytes);
+        encryptedBlocks.push(convert_1.default.uint32ToBytes(encryptedBlock));
+    }
+    const encoded = convert_1.default.concatBytes(...encryptedBlocks);
+    return encoded;
+};
+const decodeBytes = (cipherbytes, key) => {
+    // 将密文分块并解密
+    const key4LongBytes = toTeaKey(key);
+    const decryptedBlocks = [];
+    for (let i = 0; i < cipherbytes.length; i += 8) {
+        const block = convert_1.default.bytesToUint32(cipherbytes.slice(i, i + 8));
+        const decryptedBlock = decrypt(block, key4LongBytes);
+        decryptedBlocks.push(convert_1.default.uint32ToBytes(decryptedBlock));
+    }
+    const decryptedBytes = convert_1.default.concatBytes(...decryptedBlocks);
+    // 去除填充并返回明文
+    const decryptedUnpaddBytes = convert_1.default.pkcs7Unpadding(decryptedBytes);
+    return decryptedUnpaddBytes;
+};
+const encode = (plaintext, key) => {
+    // 转换明文为字节数组并进行PKCS#7填充
+    const plainBytes = convert_1.default.textEncode(plaintext);
+    const encoded = encodeBytes(plainBytes, key);
+    return convert_1.default.bytesToBase64(encoded);
+};
+const decode = (ciphertext, key) => {
+    const cipherBytes = convert_1.default.base64ToBytes(ciphertext);
+    const decryptedBytes = decodeBytes(cipherBytes, key);
+    return convert_1.default.textDecode(decryptedBytes.buffer);
+};
+exports.default = { TEAKey, encrypt, decrypt, toTeaKey, encode, decode, encodeBytes, decodeBytes };

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/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

@@ -63,6 +63,16 @@ declare const dUtil: {
         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;
+        encode: (plaintext: string, key: string) => string;
+        decode: (ciphertext: string, key: string) => string;
+        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
+        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
+    };
     uuid: (len?: number, radix?: number) => string;
     guid: (len: number, prefix?: boolean, sep?: string) => string;
     getHexString: (len: number) => string;
@@ -70,19 +80,14 @@ declare const dUtil: {
     keyLower: string;
     keyUpper: string;
     keyChars: string;
-    str2Hex: (str: string) => string;
-    hex2Str: (hexstr: string) => string;
     str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
     ab2str: (data: ArrayBuffer, base64?: boolean) => string;
-    bytesToStr: (bytes: Uint8Array) => string;
-    strToBytes: (str?: string) => Uint8Array;
     utf8ToBase64: (str: string) => string;
     base64ToUtf8: (base64Str: string) => string;
     getRandomBytes: (length: number) => Uint8Array;
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
-    concatBytes: (...args: Uint8Array[]) => Uint8Array;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -91,6 +96,19 @@ declare const dUtil: {
     fromUtf8: (utftext: string) => string;
     toUtf8Bytes: (content: string) => Uint8Array;
     fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
+    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
+    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
+    bytes2str: (bytes: Uint8Array) => string;
+    str2bytes: (str?: string) => Uint8Array;
+    str2hex: (str: string) => string;
+    hex2str: (hexstr: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
+    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
+    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
+    hex2bytes: (hex: string) => Uint8Array;
+    bytes2hex: (bytes: Uint8Array) => string;
+    toUint32: (str: string) => Uint32Array;
+    fromUint32: (uint32: Uint32Array) => string;
     gbk: {
         gbkLength: (str: string) => number;
         gbkCut: (source: string, len: number) => string;
@@ -295,8 +313,10 @@ 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>;
+    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) => Promise<[null, T_2] | [U, undefined]>;
     go: <T_3 = any>(task?: import("./typings").Ddan.PFunction<T_3> | undefined) => Promise<[any, undefined] | [null, T_3]>;
     delay: (ms?: number) => Promise<unknown>;
@@ -306,6 +326,16 @@ declare const dHook: {
         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;
+        encode: (plaintext: string, key: string) => string;
+        decode: (ciphertext: string, key: string) => string;
+        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
+        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
+    };
     uuid: (len?: number, radix?: number) => string;
     guid: (len: number, prefix?: boolean, sep?: string) => string;
     getHexString: (len: number) => string;
@@ -313,19 +343,14 @@ declare const dHook: {
     keyLower: string;
     keyUpper: string;
     keyChars: string;
-    str2Hex: (str: string) => string;
-    hex2Str: (hexstr: string) => string;
     str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
     ab2str: (data: ArrayBuffer, base64?: boolean) => string;
-    bytesToStr: (bytes: Uint8Array) => string;
-    strToBytes: (str?: string) => Uint8Array;
     utf8ToBase64: (str: string) => string;
     base64ToUtf8: (base64Str: string) => string;
     getRandomBytes: (length: number) => Uint8Array;
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
-    concatBytes: (...args: Uint8Array[]) => Uint8Array;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -334,6 +359,19 @@ declare const dHook: {
     fromUtf8: (utftext: string) => string;
     toUtf8Bytes: (content: string) => Uint8Array;
     fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
+    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
+    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
+    bytes2str: (bytes: Uint8Array) => string;
+    str2bytes: (str?: string) => Uint8Array;
+    str2hex: (str: string) => string;
+    hex2str: (hexstr: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
+    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
+    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
+    hex2bytes: (hex: string) => Uint8Array;
+    bytes2hex: (bytes: Uint8Array) => string;
+    toUint32: (str: string) => Uint32Array;
+    fromUint32: (uint32: Uint32Array) => string;
 };
 declare const dMini: {
     mini: {
@@ -616,7 +654,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;
@@ -657,8 +695,10 @@ 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>;
+        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) => Promise<[null, T_1] | [U, undefined]>;
         go: <T_2 = any>(task?: import("./typings").Ddan.PFunction<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
         delay: (ms?: number) => Promise<unknown>;
@@ -792,6 +832,16 @@ declare const _default: {
             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;
+            encode: (plaintext: string, key: string) => string;
+            decode: (ciphertext: string, key: string) => string;
+            encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
+            decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
+        };
         uuid: (len?: number, radix?: number) => string;
         guid: (len: number, prefix?: boolean, sep?: string) => string;
         getHexString: (len: number) => string;
@@ -934,19 +984,14 @@ declare const _default: {
         };
     };
     convert: {
-        str2Hex: (str: string) => string;
-        hex2Str: (hexstr: string) => string;
         str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
         ab2str: (data: ArrayBuffer, base64?: boolean) => string;
-        bytesToStr: (bytes: Uint8Array) => string;
-        strToBytes: (str?: string) => Uint8Array;
         utf8ToBase64: (str: string) => string;
         base64ToUtf8: (base64Str: string) => string;
         getRandomBytes: (length: number) => Uint8Array;
         textEncode: (text: string) => Uint8Array;
         textDecode: (buf: ArrayBufferLike) => string;
         toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
-        concatBytes: (...args: Uint8Array[]) => Uint8Array;
         toBase64: (input?: string) => string;
         fromBase64: (input?: string) => string;
         bytesToBase64: (bytes: Uint8Array) => string;
@@ -955,6 +1000,19 @@ declare const _default: {
         fromUtf8: (utftext: string) => string;
         toUtf8Bytes: (content: string) => Uint8Array;
         fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
+        pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
+        pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
+        bytes2str: (bytes: Uint8Array) => string;
+        str2bytes: (str?: string) => Uint8Array;
+        str2hex: (str: string) => string;
+        hex2str: (hexstr: string) => string;
+        concatBytes: (...args: Uint8Array[]) => Uint8Array;
+        uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
+        bytesToUint32: (bytes: Uint8Array) => Uint32Array;
+        hex2bytes: (hex: string) => Uint8Array;
+        bytes2hex: (bytes: Uint8Array) => string;
+        toUint32: (str: string) => Uint32Array;
+        fromUint32: (uint32: Uint32Array) => string;
     };
     KValue: typeof KValue;
     Mapping: typeof Mapping;

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

@@ -0,0 +1,14 @@
+declare const _default: {
+    bytes2str: (bytes: Uint8Array) => string;
+    str2bytes: (str?: string) => Uint8Array;
+    str2hex: (str: string) => string;
+    hex2str: (hexstr: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
+    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
+    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
+    hex2bytes: (hex: string) => Uint8Array;
+    bytes2hex: (bytes: Uint8Array) => string;
+    toUint32: (str: string) => Uint32Array;
+    fromUint32: (uint32: Uint32Array) => string;
+};
+export default _default;

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

@@ -1,17 +1,12 @@
 declare const _default: {
-    str2Hex: (str: string) => string;
-    hex2Str: (hexstr: string) => string;
     str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
     ab2str: (data: ArrayBuffer, base64?: boolean) => string;
-    bytesToStr: (bytes: Uint8Array) => string;
-    strToBytes: (str?: string) => Uint8Array;
     utf8ToBase64: (str: string) => string;
     base64ToUtf8: (base64Str: string) => string;
     getRandomBytes: (length: number) => Uint8Array;
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
-    concatBytes: (...args: Uint8Array[]) => Uint8Array;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -20,5 +15,18 @@ declare const _default: {
     fromUtf8: (utftext: string) => string;
     toUtf8Bytes: (content: string) => Uint8Array;
     fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
+    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
+    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
+    bytes2str: (bytes: Uint8Array) => string;
+    str2bytes: (str?: string) => Uint8Array;
+    str2hex: (str: string) => string;
+    hex2str: (hexstr: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
+    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
+    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
+    hex2bytes: (hex: string) => Uint8Array;
+    bytes2hex: (bytes: Uint8Array) => string;
+    toUint32: (str: string) => Uint32Array;
+    fromUint32: (uint32: Uint32Array) => string;
 };
 export default _default;

package/bin/types/modules/convert/pkcs.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
+    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
+};
+export default _default;

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

@@ -4,6 +4,16 @@ declare const _default: {
         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;
+        encode: (plaintext: string, key: string) => string;
+        decode: (ciphertext: string, key: string) => string;
+        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
+        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
+    };
     uuid: (len?: number, radix?: number) => string;
     guid: (len: number, prefix?: boolean, sep?: string) => string;
     getHexString: (len: number) => string;

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

@@ -0,0 +1,11 @@
+declare const _default: {
+    TEAKey: string;
+    encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
+    decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
+    toTeaKey: (str: string) => Uint32Array;
+    encode: (plaintext: string, key: string) => string;
+    decode: (ciphertext: string, key: string) => string;
+    encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
+    decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
+};
+export default _default;

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

@@ -25,8 +25,10 @@ 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>;
+    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) => Promise<[null, T] | [U, undefined]>;
     go: <T_1 = any>(task?: Ddan.PFunction<T_1> | undefined) => Promise<[any, undefined] | [null, T_1]>;
     delay: (ms?: number) => Promise<unknown>;