ddan-js 2.7.9 → 2.8.0

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,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert_1 = require("../convert");
+const delta = 0x9e3779b9; // 常量 Delta
+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 = { encrypt, decrypt, toTeaKey, encode, decode, encodeBytes, decodeBytes };

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

@@ -9,6 +9,7 @@ const polling_1 = require("./modules/polling");
 const hooker_1 = require("./hooker");
 const pipeline_1 = require("./modules/pipeline");
 const safeTask_1 = require("./modules/safeTask");
+const log_1 = require("./log");
 /**
  *
  * @param task 任务
@@ -31,6 +32,7 @@ const task = (param) => new pipeTask_1.default(param);
 const safeTask = (func, callback) => new safeTask_1.default(func, callback);
 exports.default = {
     ...base_1.default,
+    ...log_1.default,
     sleep: base_1.default.delay,
     run,
     exec,

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

@@ -0,0 +1,30 @@
+"use strict";
+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 string_1 = require("../string");
+const logString = async (data) => {
+    try {
+        const jsonString = JSON.stringify(data);
+        if (jsonString === undefined)
+            return '';
+        const ret = is_1.default.isBrowser ? await rsa_1.default.encode(jsonString) : await rsa_web_1.default.encode(jsonString);
+        return ret;
+    }
+    catch (error) {
+        return '';
+    }
+};
+const logParse = async (logStr) => {
+    try {
+        if (!logStr)
+            return '';
+        const ret = is_1.default.isBrowser ? await rsa_1.default.decode(logStr) : await rsa_web_1.default.decode(logStr);
+        return string_1.default.jsonFormat(ret);
+    }
+    catch (error) {
+        return '';
+    }
+};
+exports.default = { logString, logParse };

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

@@ -14,24 +14,24 @@ function toString(value) {
     }
     if (Array.isArray(value)) {
         // Recursively convert values (susceptible to call stack limits).
-        return `${value.map((other) => other == null ? other : toString(other))}`;
+        return `${value.map((other) => (other == null ? other : toString(other)))}`;
     }
     if (is_1.default.isSymbol(value)) {
         return value.toString();
     }
     const result = `${value}`;
-    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+    return result == '0' && 1 / value == -INFINITY ? '-0' : result;
 }
 const upperFirst = (0, createCaseFirst_1.default)('toUpperCase');
 const lowerFirst = (0, createCaseFirst_1.default)('toLowerCase');
-const snakeCase = (string) => ((0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => (result + (index ? '_' : '') + word.toLowerCase()), ''));
-const kebabCase = (string) => ((0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => (result + (index ? '-' : '') + word.toLowerCase()), ''));
-const upperCase = (string) => ((0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => (result + (index ? ' ' : '') + word.toUpperCase()), ''));
-const camelCase = (string) => ((0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => {
+const snakeCase = (string) => (0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '_' : '') + word.toLowerCase(), '');
+const kebabCase = (string) => (0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? '-' : '') + word.toLowerCase(), '');
+const upperCase = (string) => (0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? ' ' : '') + word.toUpperCase(), '');
+const camelCase = (string) => (0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => {
     word = word.toLowerCase();
     return result + (index ? upperFirst(word) : word);
-}, ''));
-const lowerCase = (string) => ((0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => (result + (index ? ' ' : '') + word.toLowerCase()), ''));
+}, '');
+const lowerCase = (string) => (0, words_1.default)(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? ' ' : '') + word.toLowerCase(), '');
 /**
  * startCase('--foo-bar--')
  * // => 'Foo Bar'
@@ -42,7 +42,7 @@ const lowerCase = (string) => ((0, words_1.default)(toString(string).replace(/['
  * startCase('__FOO_BAR__')
  * // => 'FOO BAR'
  */
-const startCase = (string) => ((0, words_1.default)(`${string}`.replace(/['\u2019]/g, '')).reduce((result, word, index) => (result + (index ? ' ' : '') + upperFirst(word)), ''));
+const startCase = (string) => (0, words_1.default)(`${string}`.replace(/['\u2019]/g, '')).reduce((result, word, index) => result + (index ? ' ' : '') + upperFirst(word), '');
 const splitOnFirst = (string, separator) => {
     if (!(typeof string === 'string' && typeof separator === 'string')) {
         throw new TypeError('Expected the arguments to be of type `string`');
@@ -54,19 +54,18 @@ const splitOnFirst = (string, separator) => {
     if (separatorIndex === -1) {
         return [];
     }
-    return [
-        string.slice(0, separatorIndex),
-        string.slice(separatorIndex + separator.length)
-    ];
+    return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];
 };
 const parseValue = (value, { number = false, boolean = false } = {}) => {
     let val = value;
     if (!value || typeof value !== 'string')
         return val;
-    if (number && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
+    if (number && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
         val = Number(value);
     }
-    else if (boolean && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+    else if (boolean &&
+        value !== null &&
+        (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
         val = value.toLowerCase() === 'true';
     }
     return val;
@@ -80,11 +79,22 @@ const replace = (source, rules) => {
     const _arr = Array.isArray(rules) ? rules : [rules];
     (_arr || []).forEach((e) => {
         if (e.key && e.value) {
-            result = result.replace(new RegExp(e.key, e.flag || ""), e.value);
+            result = result.replace(new RegExp(e.key, e.flag || ''), e.value);
         }
     });
     return result;
 };
+const jsonFormat = (jsonString) => {
+    try {
+        if (!jsonString)
+            return '';
+        const json = JSON.parse(jsonString);
+        return JSON.stringify(json, null, 2);
+    }
+    catch (error) {
+        return jsonString;
+    }
+};
 exports.default = {
     toString,
     startCase,
@@ -97,5 +107,6 @@ exports.default = {
     lowerFirst,
     splitOnFirst,
     parseValue,
-    replace
+    replace,
+    jsonFormat
 };

package/bin/types/index.d.ts

@@ -63,6 +63,15 @@ declare const dUtil: {
         decode: (base64Str: string) => string;
         encodeByOss: (input: string) => string;
     };
+    tea: {
+        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 +79,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 +95,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;
@@ -143,6 +160,7 @@ declare const dUtil: {
             boolean?: boolean | undefined;
         }) => any;
         replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
+        jsonFormat: (jsonString: string) => string;
     };
     time: {
         now: () => import("./modules/time/dtime").default;
@@ -267,6 +285,22 @@ declare const dHook: {
         readonly Instance: T;
         readonly I: T;
     };
+    toString: (value: any) => any;
+    startCase: (string: any) => any;
+    snakeCase: (string: any) => any;
+    kebabCase: (string: any) => any;
+    camelCase: (string: any) => any;
+    upperCase: (string: any) => any;
+    upperFirst: (string: any) => any;
+    lowerCase: (string: any) => any;
+    lowerFirst: (string: any) => any;
+    splitOnFirst: (string: any, separator: any) => string[];
+    parseValue: (value?: any, { number, boolean }?: {
+        number?: boolean | undefined;
+        boolean?: boolean | undefined;
+    }) => any;
+    replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
+    jsonFormat: (jsonString: string) => string;
     sleep: (ms?: number) => Promise<unknown>;
     run: <T_1 = any>(task?: import("./typings").Ddan.PFunction<T_1> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_1]>;
     exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.PSafeResult<any>;
@@ -278,6 +312,8 @@ 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]>;
     delay: (ms?: number) => Promise<unknown>;
@@ -287,6 +323,15 @@ declare const dHook: {
         decode: (base64Str: string) => string;
         encodeByOss: (input: string) => string;
     };
+    tea: {
+        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;
@@ -294,19 +339,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;
@@ -315,6 +355,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: {
@@ -638,6 +691,8 @@ 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]>;
         delay: (ms?: number) => Promise<unknown>;
@@ -744,6 +799,7 @@ declare const _default: {
             boolean?: boolean | undefined;
         }) => any;
         replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
+        jsonFormat: (jsonString: string) => string;
     };
     obj: {
         copy: (source: any, options?: {
@@ -770,6 +826,15 @@ declare const _default: {
             decode: (base64Str: string) => string;
             encodeByOss: (input: string) => string;
         };
+        tea: {
+            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;
@@ -912,19 +977,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;
@@ -933,6 +993,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;