ddan-js 2.9.3 → 2.9.5

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

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utf8_1 = require("./utf8");
-const is_1 = require("../../util/is");
-const BaseKey = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-const bytesToBase64 = (bytes) => {
-    let output = '';
-    let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
-    let i = 0;
-    if (!bytes || !is_1.default.isArrayLike(bytes) || !is_1.default.isUint8Array(bytes))
-        return '';
-    while (i < bytes.length) {
-        chr1 = bytes[i++];
-        chr2 = bytes[i++];
-        chr3 = bytes[i++];
-        enc1 = chr1 >> 2;
-        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
-        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
-        enc4 = chr3 & 63;
-        if (isNaN(chr2)) {
-            enc3 = enc4 = 64;
-        }
-        else if (isNaN(chr3)) {
-            enc4 = 64;
-        }
-        output =
-            output +
-                BaseKey.charAt(enc1) +
-                BaseKey.charAt(enc2) +
-                BaseKey.charAt(enc3) +
-                BaseKey.charAt(enc4);
-    }
-    return output;
-};
-const toBase64 = (input = "") => {
-    let output = '';
-    let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
-    let i = 0;
-    input = utf8_1.default.toUtf8(input);
-    while (i < input.length) {
-        chr1 = input.charCodeAt(i++);
-        chr2 = input.charCodeAt(i++);
-        chr3 = input.charCodeAt(i++);
-        enc1 = chr1 >> 2;
-        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
-        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
-        enc4 = chr3 & 63;
-        if (isNaN(chr2)) {
-            enc3 = enc4 = 64;
-        }
-        else if (isNaN(chr3)) {
-            enc4 = 64;
-        }
-        output =
-            output +
-                BaseKey.charAt(enc1) +
-                BaseKey.charAt(enc2) +
-                BaseKey.charAt(enc3) +
-                BaseKey.charAt(enc4);
-    }
-    return output;
-};
-const base64ToBytes = (input = "") => {
-    let output = [];
-    let chr1, chr2, chr3;
-    let enc1, enc2, enc3, enc4;
-    let i = 0;
-    // Remove any characters that are not valid Base64
-    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
-    while (i < input.length) {
-        enc1 = BaseKey.indexOf(input.charAt(i++));
-        enc2 = BaseKey.indexOf(input.charAt(i++));
-        enc3 = BaseKey.indexOf(input.charAt(i++));
-        enc4 = BaseKey.indexOf(input.charAt(i++));
-        chr1 = (enc1 << 2) | (enc2 >> 4);
-        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
-        chr3 = ((enc3 & 3) << 6) | enc4;
-        output.push(chr1);
-        if (enc3 != 64) {
-            output.push(chr2);
-        }
-        if (enc4 != 64) {
-            output.push(chr3);
-        }
-    }
-    // Convert the array to Uint8Array and return
-    return new Uint8Array(output);
-};
-const fromBase64 = (input = "") => {
-    let output = '';
-    let chr1, chr2, chr3;
-    let enc1, enc2, enc3, enc4;
-    let i = 0;
-    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
-    while (i < input.length) {
-        enc1 = BaseKey.indexOf(input.charAt(i++));
-        enc2 = BaseKey.indexOf(input.charAt(i++));
-        enc3 = BaseKey.indexOf(input.charAt(i++));
-        enc4 = BaseKey.indexOf(input.charAt(i++));
-        chr1 = (enc1 << 2) | (enc2 >> 4);
-        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
-        chr3 = ((enc3 & 3) << 6) | enc4;
-        output = output + String.fromCharCode(chr1);
-        if (enc3 != 64) {
-            output = output + String.fromCharCode(chr2);
-        }
-        if (enc4 != 64) {
-            output = output + String.fromCharCode(chr3);
-        }
-    }
-    output = utf8_1.default.fromUtf8(output);
-    return output;
-};
-exports.default = { toBase64, fromBase64, bytesToBase64, base64ToBytes };

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

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 md5_1 = require("./md5");
-const str2ab = (content = '', base64 = false) => {
-    if (base64) {
-        return base64_1.default.base64ToBytes(content).buffer;
-    }
-    else {
-        const buf = new ArrayBuffer(content.length);
-        const bufView = new Uint8Array(buf);
-        for (let i = 0, strLen = content.length; i < strLen; i++) {
-            bufView[i] = content.charCodeAt(i);
-        }
-        return buf;
-    }
-};
-const ab2str = (data, base64 = false) => {
-    const uint8Array = new Uint8Array(data);
-    if (base64) {
-        return base64_1.default.bytesToBase64(uint8Array);
-    }
-    else {
-        return uint8Array.reduce((str, byte) => str + String.fromCharCode(byte), '');
-    }
-};
-const utf8ToBase64 = (str) => {
-    if (is_1.default.isBrowser) {
-        return btoa(str);
-    }
-    else {
-        return Buffer.from(str, 'utf-8').toString('base64');
-    }
-};
-const base64ToUtf8 = (base64Str) => {
-    if (is_1.default.isBrowser) {
-        return atob(base64Str);
-    }
-    else {
-        return Buffer.from(base64Str, 'base64').toString('utf-8');
-    }
-};
-const getRandomBytes = (length) => {
-    const randomBytes = new Uint8Array(length);
-    // 使用 Math.random() 生成伪随机字节
-    for (let i = 0; i < length; i++) {
-        randomBytes[i] = math_1.default.random(256); // 生成 0-255 的随机数
-    }
-    return randomBytes;
-};
-/**
- * utf-8 encode
- * new TextEncoder().encode(data);
- * @param text
- * @returns
- */
-const textEncode = (text) => {
-    return utf8_1.default.toUtf8Bytes(text);
-};
-/**
- * utf-8 decode
- * new TextDecoder().decode(buf)
- * @param buf
- * @returns
- */
-const textDecode = (buf) => {
-    return utf8_1.default.fromUtf8Bytes(new Uint8Array(buf));
-};
-const toDataUrl = (textOrBuf, contentType = 'text/plain') => {
-    if (!textOrBuf)
-        return '';
-    if (typeof textOrBuf === 'string') {
-        return `data:${contentType};base64,` + base64_1.default.toBase64(textOrBuf);
-    }
-    if (is_1.default.isArrayBuffer(textOrBuf)) {
-        return `data:${contentType};base64,` + ab2str(textOrBuf, true);
-    }
-    return '';
-};
-exports.default = {
-    ...base_1.default,
-    ...pkcs_1.default,
-    ...utf8_1.default,
-    ...base64_1.default,
-    ...md5_1.default,
-    str2ab,
-    ab2str,
-    utf8ToBase64,
-    base64ToUtf8,
-    getRandomBytes,
-    textEncode,
-    textDecode,
-    toDataUrl,
-};

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

@@ -1,222 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utf8_1 = require("./utf8");
-const base_1 = require("./base");
-const base64_1 = require("./base64");
-function rotateLeft(lValue, iShiftBits) {
-    return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
-}
-function addUnsigned(lX, lY) {
-    let lX4;
-    let lY4;
-    let lX8;
-    let lY8;
-    let lResult;
-    lX8 = lX & 0x80000000;
-    lY8 = lY & 0x80000000;
-    lX4 = lX & 0x40000000;
-    lY4 = lY & 0x40000000;
-    lResult = (lX & 0x3fffffff) + (lY & 0x3fffffff);
-    if (lX4 & lY4) {
-        return lResult ^ 0x80000000 ^ lX8 ^ lY8;
-    }
-    if (lX4 | lY4) {
-        if (lResult & 0x40000000) {
-            return lResult ^ 0xc0000000 ^ lX8 ^ lY8;
-        }
-        else {
-            return lResult ^ 0x40000000 ^ lX8 ^ lY8;
-        }
-    }
-    else {
-        return lResult ^ lX8 ^ lY8;
-    }
-}
-function F(x, y, z) {
-    return (x & y) | (~x & z);
-}
-function G(x, y, z) {
-    return (x & z) | (y & ~z);
-}
-function H(x, y, z) {
-    return x ^ y ^ z;
-}
-function I(x, y, z) {
-    return y ^ (x | ~z);
-}
-function FF(a, b, c, d, x, s, ac) {
-    a = addUnsigned(a, addUnsigned(addUnsigned(F(b, c, d), x), ac));
-    return addUnsigned(rotateLeft(a, s), b);
-}
-function GG(a, b, c, d, x, s, ac) {
-    a = addUnsigned(a, addUnsigned(addUnsigned(G(b, c, d), x), ac));
-    return addUnsigned(rotateLeft(a, s), b);
-}
-function HH(a, b, c, d, x, s, ac) {
-    a = addUnsigned(a, addUnsigned(addUnsigned(H(b, c, d), x), ac));
-    return addUnsigned(rotateLeft(a, s), b);
-}
-function II(a, b, c, d, x, s, ac) {
-    a = addUnsigned(a, addUnsigned(addUnsigned(I(b, c, d), x), ac));
-    return addUnsigned(rotateLeft(a, s), b);
-}
-function convertToWordArray(data) {
-    let lWordCount;
-    const lMessageLength = data.length;
-    const lNumberOfWordsTemp1 = lMessageLength + 8;
-    const lNumberOfWordsTemp2 = (lNumberOfWordsTemp1 - (lNumberOfWordsTemp1 % 64)) / 64;
-    const lNumberOfWords = (lNumberOfWordsTemp2 + 1) * 16;
-    const lWordArray = Array(lNumberOfWords - 1).fill(0);
-    let lBytePosition = 0;
-    let lByteCount = 0;
-    // Process each byte from the Uint8Array
-    while (lByteCount < lMessageLength) {
-        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
-        lBytePosition = (lByteCount % 4) * 8;
-        lWordArray[lWordCount] = lWordArray[lWordCount] | (data[lByteCount] << lBytePosition);
-        lByteCount++;
-    }
-    // Append padding bits
-    lWordCount = (lByteCount - (lByteCount % 4)) / 4;
-    lBytePosition = (lByteCount % 4) * 8;
-    lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
-    // Append message length in bits
-    lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
-    lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
-    return lWordArray;
-}
-function wordToHex(lValue) {
-    let wordToHexValue = '';
-    let wordToHexValueTemp = '';
-    let lByte;
-    let lCount;
-    for (lCount = 0; lCount <= 3; lCount++) {
-        lByte = (lValue >>> (lCount * 8)) & 255;
-        wordToHexValueTemp = '0' + lByte.toString(16);
-        wordToHexValue = wordToHexValue + wordToHexValueTemp.substr(wordToHexValueTemp.length - 2, 2);
-    }
-    return wordToHexValue;
-}
-function hash(bytes) {
-    let x = [];
-    let k;
-    let AA;
-    let BB;
-    let CC;
-    let DD;
-    let a;
-    let b;
-    let c;
-    let d;
-    const S11 = 7;
-    const S12 = 12;
-    const S13 = 17;
-    const S14 = 22;
-    const S21 = 5;
-    const S22 = 9;
-    const S23 = 14;
-    const S24 = 20;
-    const S31 = 4;
-    const S32 = 11;
-    const S33 = 16;
-    const S34 = 23;
-    const S41 = 6;
-    const S42 = 10;
-    const S43 = 15;
-    const S44 = 21;
-    x = convertToWordArray(bytes);
-    a = 0x67452301;
-    b = 0xefcdab89;
-    c = 0x98badcfe;
-    d = 0x10325476;
-    for (k = 0; k < x.length; k += 16) {
-        AA = a;
-        BB = b;
-        CC = c;
-        DD = d;
-        a = FF(a, b, c, d, x[k + 0], S11, 0xd76aa478);
-        d = FF(d, a, b, c, x[k + 1], S12, 0xe8c7b756);
-        c = FF(c, d, a, b, x[k + 2], S13, 0x242070db);
-        b = FF(b, c, d, a, x[k + 3], S14, 0xc1bdceee);
-        a = FF(a, b, c, d, x[k + 4], S11, 0xf57c0faf);
-        d = FF(d, a, b, c, x[k + 5], S12, 0x4787c62a);
-        c = FF(c, d, a, b, x[k + 6], S13, 0xa8304613);
-        b = FF(b, c, d, a, x[k + 7], S14, 0xfd469501);
-        a = FF(a, b, c, d, x[k + 8], S11, 0x698098d8);
-        d = FF(d, a, b, c, x[k + 9], S12, 0x8b44f7af);
-        c = FF(c, d, a, b, x[k + 10], S13, 0xffff5bb1);
-        b = FF(b, c, d, a, x[k + 11], S14, 0x895cd7be);
-        a = FF(a, b, c, d, x[k + 12], S11, 0x6b901122);
-        d = FF(d, a, b, c, x[k + 13], S12, 0xfd987193);
-        c = FF(c, d, a, b, x[k + 14], S13, 0xa679438e);
-        b = FF(b, c, d, a, x[k + 15], S14, 0x49b40821);
-        a = GG(a, b, c, d, x[k + 1], S21, 0xf61e2562);
-        d = GG(d, a, b, c, x[k + 6], S22, 0xc040b340);
-        c = GG(c, d, a, b, x[k + 11], S23, 0x265e5a51);
-        b = GG(b, c, d, a, x[k + 0], S24, 0xe9b6c7aa);
-        a = GG(a, b, c, d, x[k + 5], S21, 0xd62f105d);
-        d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
-        c = GG(c, d, a, b, x[k + 15], S23, 0xd8a1e681);
-        b = GG(b, c, d, a, x[k + 4], S24, 0xe7d3fbc8);
-        a = GG(a, b, c, d, x[k + 9], S21, 0x21e1cde6);
-        d = GG(d, a, b, c, x[k + 14], S22, 0xc33707d6);
-        c = GG(c, d, a, b, x[k + 3], S23, 0xf4d50d87);
-        b = GG(b, c, d, a, x[k + 8], S24, 0x455a14ed);
-        a = GG(a, b, c, d, x[k + 13], S21, 0xa9e3e905);
-        d = GG(d, a, b, c, x[k + 2], S22, 0xfcefa3f8);
-        c = GG(c, d, a, b, x[k + 7], S23, 0x676f02d9);
-        b = GG(b, c, d, a, x[k + 12], S24, 0x8d2a4c8a);
-        a = HH(a, b, c, d, x[k + 5], S31, 0xfffa3942);
-        d = HH(d, a, b, c, x[k + 8], S32, 0x8771f681);
-        c = HH(c, d, a, b, x[k + 11], S33, 0x6d9d6122);
-        b = HH(b, c, d, a, x[k + 14], S34, 0xfde5380c);
-        a = HH(a, b, c, d, x[k + 1], S31, 0xa4beea44);
-        d = HH(d, a, b, c, x[k + 4], S32, 0x4bdecfa9);
-        c = HH(c, d, a, b, x[k + 7], S33, 0xf6bb4b60);
-        b = HH(b, c, d, a, x[k + 10], S34, 0xbebfbc70);
-        a = HH(a, b, c, d, x[k + 13], S31, 0x289b7ec6);
-        d = HH(d, a, b, c, x[k + 0], S32, 0xeaa127fa);
-        c = HH(c, d, a, b, x[k + 3], S33, 0xd4ef3085);
-        b = HH(b, c, d, a, x[k + 6], S34, 0x4881d05);
-        a = HH(a, b, c, d, x[k + 9], S31, 0xd9d4d039);
-        d = HH(d, a, b, c, x[k + 12], S32, 0xe6db99e5);
-        c = HH(c, d, a, b, x[k + 15], S33, 0x1fa27cf8);
-        b = HH(b, c, d, a, x[k + 2], S34, 0xc4ac5665);
-        a = II(a, b, c, d, x[k + 0], S41, 0xf4292244);
-        d = II(d, a, b, c, x[k + 7], S42, 0x432aff97);
-        c = II(c, d, a, b, x[k + 14], S43, 0xab9423a7);
-        b = II(b, c, d, a, x[k + 5], S44, 0xfc93a039);
-        a = II(a, b, c, d, x[k + 12], S41, 0x655b59c3);
-        d = II(d, a, b, c, x[k + 3], S42, 0x8f0ccc92);
-        c = II(c, d, a, b, x[k + 10], S43, 0xffeff47d);
-        b = II(b, c, d, a, x[k + 1], S44, 0x85845dd1);
-        a = II(a, b, c, d, x[k + 8], S41, 0x6fa87e4f);
-        d = II(d, a, b, c, x[k + 15], S42, 0xfe2ce6e0);
-        c = II(c, d, a, b, x[k + 6], S43, 0xa3014314);
-        b = II(b, c, d, a, x[k + 13], S44, 0x4e0811a1);
-        a = II(a, b, c, d, x[k + 4], S41, 0xf7537e82);
-        d = II(d, a, b, c, x[k + 11], S42, 0xbd3af235);
-        c = II(c, d, a, b, x[k + 2], S43, 0x2ad7d2bb);
-        b = II(b, c, d, a, x[k + 9], S44, 0xeb86d391);
-        a = addUnsigned(a, AA);
-        b = addUnsigned(b, BB);
-        c = addUnsigned(c, CC);
-        d = addUnsigned(d, DD);
-    }
-    return wordToHex(a) + wordToHex(b) + wordToHex(c) + wordToHex(d);
-}
-const md5 = (input) => {
-    if (typeof input !== 'string' && !(input instanceof Uint8Array)) {
-        return '';
-    }
-    const bytes = typeof input === 'string' ? utf8_1.default.toUtf8Bytes(input) : input;
-    return hash(bytes);
-};
-const md5Base64 = (input) => {
-    const hex = md5(input);
-    if (!hex)
-        return '';
-    const bytes = base_1.default.hex2bytes(hex);
-    return base64_1.default.bytesToBase64(bytes);
-};
-exports.default = { md5, md5Base64 };

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

@@ -1,16 +0,0 @@
-"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/convert/utf8.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const toUtf8 = (content) => {
-    if (!content)
-        return '';
-    const string = content.replace(/\r\n/g, '\n');
-    let utftext = '';
-    for (let n = 0; n < string.length; n++) {
-        let c = string.charCodeAt(n);
-        if (c < 128) {
-            utftext += String.fromCharCode(c);
-        }
-        else if (c > 127 && c < 2048) {
-            utftext += String.fromCharCode((c >> 6) | 192);
-            utftext += String.fromCharCode((c & 63) | 128);
-        }
-        else {
-            utftext += String.fromCharCode((c >> 12) | 224);
-            utftext += String.fromCharCode(((c >> 6) & 63) | 128);
-            utftext += String.fromCharCode((c & 63) | 128);
-        }
-    }
-    return utftext;
-};
-const toUtf8Bytes = (content) => {
-    if (!content)
-        return new Uint8Array();
-    const string = content.replace(/\r\n/g, '\n');
-    const utf8 = [];
-    for (let n = 0; n < string.length; n++) {
-        let c = string.charCodeAt(n);
-        if (c < 128) {
-            utf8.push(c);
-        }
-        else if (c < 2048) {
-            utf8.push((c >> 6) | 192);
-            utf8.push((c & 63) | 128);
-        }
-        else {
-            utf8.push((c >> 12) | 224);
-            utf8.push(((c >> 6) & 63) | 128);
-            utf8.push((c & 63) | 128);
-        }
-    }
-    return new Uint8Array(utf8);
-};
-const fromUtf8 = (utftext) => {
-    let result = '';
-    let i = 0;
-    if (!utftext)
-        return '';
-    let c = 0, c1 = 0, c2 = 0, c3 = 0;
-    while (i < utftext.length) {
-        c = utftext.charCodeAt(i);
-        if (c < 128) {
-            result += String.fromCharCode(c);
-            i++;
-        }
-        else if (c > 191 && c < 224) {
-            c2 = utftext.charCodeAt(i + 1);
-            result += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
-            i += 2;
-        }
-        else {
-            c2 = utftext.charCodeAt(i + 1);
-            c3 = utftext.charCodeAt(i + 2);
-            result += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
-            i += 3;
-        }
-    }
-    return result;
-};
-const fromUtf8Bytes = (utf8Bytes) => {
-    let result = '';
-    let i = 0;
-    if (!utf8Bytes || utf8Bytes.length <= 0)
-        return '';
-    while (i < utf8Bytes.length) {
-        let c = utf8Bytes[i];
-        // 单字节字符 (ASCII)
-        if (c < 128) {
-            result += String.fromCharCode(c);
-            i++;
-        }
-        // 双字节字符
-        else if (c > 191 && c < 224) {
-            const c2 = utf8Bytes[i + 1];
-            result += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
-            i += 2;
-        }
-        // 三字节字符
-        else {
-            const c2 = utf8Bytes[i + 1];
-            const c3 = utf8Bytes[i + 2];
-            result += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
-            i += 3;
-        }
-    }
-    return result;
-};
-exports.default = {
-    toUtf8,
-    fromUtf8,
-    toUtf8Bytes,
-    fromUtf8Bytes
-};

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const base64_1 = require("../convert/base64");
-const encode = (input) => {
-    return base64_1.default.toBase64(input);
-};
-const encodeByOss = (input) => {
-    // base64编码并部分替换
-    return encode(input).replace(/\+/g, '-').replace(/\//g, '_').replace(/\=/g, '');
-};
-const decode = (base64Str) => {
-    return base64_1.default.fromBase64(base64Str);
-};
-exports.default = { encode, decode, encodeByOss };

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keyNumber = "0123456789";
-const keyLower = "abcdefghijklmnopqrstuvwxyz";
-const keyUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-const keyChars = keyNumber + keyLower + keyUpper;
-exports.default = { keyNumber, keyLower, keyUpper, keyChars };

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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)
-        return pwd;
-    return time_1.default.now().format("yyyyMMddhhmmss") + sep + pwd;
-};
-const getHexString = (len) => {
-    const characters = const_1.default.keyChars;
-    let result = '';
-    const charactersLength = characters.length;
-    for (let i = 0; i < len; i++) {
-        result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    }
-    return result;
-};
-exports.default = {
-    ...const_1.default,
-    base64: base64_1.default,
-    tea: tea_1.default,
-    uuid: uuid_1.default,
-    guid,
-    getHexString
-};