ddan-js 2.9.4 → 2.9.6

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
-};

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

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const convert_1 = require("../convert");
-const RSAPublicKey = `MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApiLWsPmoaiGdr02AmPYS
-4/VgxyJNNJSK2VICirXl4P8qAP3b/6GIs7Hwnsmmuj7gledJ0XiZodFjDNgQEZEG
-j4K9KX8NixcrJwnTQV5UebiERdj+64ihwqPVWo9dIOj43ZPJ8f4dritJv5tnQaBb
-b9zTkU3Ofzk1g8RU00Ith6quOGZcU2IWC4OQ+5YiZvzrCBKEvjFwK2OvGq43tI51
-GaZdI9H09jisypqefsMvv6esjEQQOtl+WGlI5fof7KZUt3dppvuDI4CYgeXIoKKL
-9T9qDl8F9aNSs3XHx32YyA7L1FraFD6PjqRjueIFp2emsXQcIMeMqqgVyV+4qb+0
-uwIDAQAB`;
-const RSAPrivateKey = `MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCmItaw+ahqIZ2v
-TYCY9hLj9WDHIk00lIrZUgKKteXg/yoA/dv/oYizsfCeyaa6PuCV50nReJmh0WMM
-2BARkQaPgr0pfw2LFysnCdNBXlR5uIRF2P7riKHCo9Vaj10g6Pjdk8nx/h2uK0m/
-m2dBoFtv3NORTc5/OTWDxFTTQi2Hqq44ZlxTYhYLg5D7liJm/OsIEoS+MXArY68a
-rje0jnUZpl0j0fT2OKzKmp5+wy+/p6yMRBA62X5YaUjl+h/splS3d2mm+4MjgJiB
-5cigoov1P2oOXwX1o1KzdcfHfZjIDsvUWtoUPo+OpGO54gWnZ6axdBwgx4yqqBXJ
-X7ipv7S7AgMBAAECggEAE1kuWLkSsJ2OoDpt9iJ+a7cJmNd5V1zPWOTwr9fkWFJP
-QYNPKlPVOFxKUivY84rcHAkuMyuQ9OQOXZISOQGDWpZW0mzeFmtR1r+Rr2S9gNmI
-6huOAL9OW306HUxiA7GuPhv2omy+Zyjac2q1WVLEI2B78Um2+WEfxuNIH7xu0gRR
-z/wluevMBQlv6hSeMESP6e9s2kB+FuM4bL7+1sexwS1TudKbHybujaiB8un9E2V3
-C9BkE6yf00Rhvii6Q4E4w3PFQfcBEFnjOD0S2Watx8GIbYjlYvtquy8Yj7OtyZB6
-w5sxyaYhKVVnkpGAbOgaCj94ABYF47VuwXr45I4PzQKBgQDp6svzD+QKlARjcWgO
-rH7UEpFX6m49G6Ib4c63xEg9+GesTgfDxoYxtXDKsC7I8OwMrmffJGbyfjaAvzmg
-icM3Y7kF6UPO9+q2mBRsyhoJSNONTeUVyoFSc+QDsVgndlTZIjqC5XLrONGaSPLJ
-7jJzqKhp3NQcpO8+xY0d7Efm1QKBgQC10fCNuF1LUTYgsWvvGxTiCCAIBurZmHU+
-GMb2Okfoco/P+QNl1jEba91AC7FudW3g/lRn0vTnDajlNoz2/CKunrTKN4/9lEBI
-tiwEOvhc5FtapRifSfrrNwFqPM+LijvOkcteWVhAUWCEP1eLmpnXGqfmZxnTaaVe
-5DyDgyAVTwKBgQDhEawfOQEANJ9sV2f6BnsZ7quuXcCoR3hZP5G5O8EO735BSesq
-sk/YcG4QeCjr6vQU15LWH552YH5srpHyJ9uP5gHW8DTwZZaPDhFJA8S9fjcfVP3B
-U9HO1fdknjTl83N8YPTPkZpbPZZfzyTcqrYclwFEqtfkn8YbLdW0Hu6n6QKBgDEv
-jvS3uD1ExfDILlurptWSvx+Mx4F/1c+roj8/+u3t9+uaAIpPDE/PuTW3NBOens/r
-3WeM0QWkU1lWjYHPKY61jlDaARDnRxCkf3nRfhibCf+Wg/erar6wzagwtTCZf55d
-IHfwkYgsu4BrJkK02wMuydbxczIW9U6bTaeCFG7PAoGAN3oHYzTEBwZ7ZKv11QiQ
-Ep/HeHBvD8fH/e1uVyBel4Co7NO5pV2s8qjS8+3+jxumKLNXCirjqwHo03YCdzxi
-cy4GFDsukHmDQ7FF9VC4QV0fJ0F7jGYE9nNZ+K9qwS5KrihOSBPxj0HptrF6TSOw
-BTSwr0byL3TC0m0StkSNKpo=`;
-const generateKeys = async (subtle) => {
-    try {
-        // 生成RSA密钥对
-        const keyPair = await subtle.generateKey({
-            name: 'RSA-OAEP',
-            modulusLength: 2048,
-            publicExponent: new Uint8Array([1, 0, 1]),
-            hash: 'SHA-256',
-        }, true, // 是否可导出密钥
-        ['encrypt', 'decrypt']);
-        // 导出公钥为SPKI格式（可共享）
-        const publicBuffer = await window.crypto.subtle.exportKey('spki', keyPair.publicKey);
-        const publicKey = format_pem_content(publicBuffer);
-        const publicKeyPem = format_pem_key(publicKey, 'PUBLIC KEY');
-        // 导出私钥为PKCS#8格式（需保护）
-        const privateBuffer = await window.crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
-        const privateKey = format_pem_content(privateBuffer);
-        const privateKeyPem = format_pem_key(privateKey, 'PRIVATE KEY');
-        return {
-            publicKey,
-            publicKeyPem,
-            privateKey,
-            privateKeyPem,
-        };
-    }
-    catch (err) {
-        console.error('generateKeys failed:', err);
-        return {
-            publicKey: '',
-            publicKeyPem: '',
-            privateKey: '',
-            privateKeyPem: '',
-        };
-    }
-};
-const format_pem_content = (buffer) => {
-    try {
-        const base64String = convert_1.default.ab2str(buffer, true);
-        return base64String.match(/.{1,64}/g)?.join('\n') || '';
-    }
-    catch (error) {
-        return '';
-    }
-};
-const format_pem_key = (pemContent = '', label = 'PUBLIC KEY') => {
-    return `-----BEGIN ${label}-----\n${pemContent}\n-----END ${label}-----`;
-};
-// SHA256: 256 - 2 - 2*32  = 190
-// SHA1: 256 - 2 - 2*20  = 214
-const maxChunkSize = 190;
-const encrypt = async (subtle, data, publicKey) => {
-    try {
-        const bytes = new TextEncoder().encode(data);
-        const key = await subtle.importKey('spki', convert_1.default.str2ab(publicKey, true), {
-            name: 'RSA-OAEP',
-            hash: 'SHA-256',
-        }, true, ['encrypt']);
-        const encryptedChunks = [];
-        for (let i = 0; i < bytes.length; i += maxChunkSize) {
-            let chunk = bytes.slice(i, i + maxChunkSize);
-            let encryptedChunk = await subtle.encrypt({
-                name: 'RSA-OAEP',
-            }, key, chunk);
-            encryptedChunks.push(new Uint8Array(encryptedChunk));
-        }
-        const enctryptedBytes = convert_1.default.concatBytes(...encryptedChunks);
-        return convert_1.default.bytesToBase64(enctryptedBytes);
-    }
-    catch (error) {
-        console.error(`[debug] encrypt`, error);
-        return '';
-    }
-};
-const decrypt = async (subtle, encryptedBase64, privateKey) => {
-    try {
-        const encrypted = convert_1.default.base64ToBytes(encryptedBase64);
-        const key = await subtle.importKey('pkcs8', convert_1.default.str2ab(privateKey, true), {
-            name: 'RSA-OAEP',
-            hash: 'SHA-256',
-        }, true, ['decrypt']);
-        const decryptedChunks = [];
-        const chunkSize = 256; // 每个加密块的大小（2048位 RSA 的加密输出为 256 字节）
-        for (let i = 0; i < encrypted.length; i += chunkSize) {
-            let chunk = encrypted.slice(i, i + chunkSize);
-            let decryptedChunk = await subtle.decrypt({
-                name: 'RSA-OAEP',
-            }, key, chunk);
-            // 添加解密后的数据
-            decryptedChunks.push(new Uint8Array(decryptedChunk));
-        }
-        const encryptedBytes = convert_1.default.concatBytes(...decryptedChunks);
-        return new TextDecoder().decode(encryptedBytes);
-    }
-    catch (err) {
-        console.error('decrypt failed:', err);
-        return '';
-    }
-};
-exports.default = {
-    RSAPublicKey,
-    RSAPrivateKey,
-    generateKeys,
-    format_pem_key,
-    format_pem_content,
-    encrypt,
-    decrypt,
-};