midway-fatcms 0.0.1-beta.71 → 0.0.1-beta.72

package/dist/libs/utils/AsymmetricCrypto.js

@@ -1,261 +1,261 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsymmetricCrypto = void 0;
-function getCrypto() {
-    if (typeof crypto !== 'undefined' && crypto.subtle) {
-        // 浏览器环境或Node.js 19+的global.crypto
-        return crypto;
-    }
-    else if (typeof global !== 'undefined') {
-        // Node.js环境
-        if (global.crypto && global.crypto.subtle) {
-            // Node.js 19+
-            return global.crypto;
-        }
-        // @ts-ignore
-        else if (global.crypto && global.crypto.webcrypto && global.crypto.webcrypto.subtle) {
-            // Node.js 16+
-            // @ts-ignore
-            return global.crypto.webcrypto;
-        }
-        else {
-            // Node.js 16-18，使用crypto.webcrypto
-            const nodeCrypto = require('crypto');
-            if (nodeCrypto.webcrypto && nodeCrypto.webcrypto.subtle) {
-                return nodeCrypto.webcrypto;
-            }
-            throw new Error('Node.js版本低于16或缺少webcrypto支持');
-        }
-    }
-    throw new Error('当前环境不支持Web Crypto API');
-}
-class AsymmetricCrypto {
-    /**
-     * 生成RSA密钥对并返回字符串格式的公钥和私钥
-     * @param {number} modulusLength - 密钥长度，默认2048
-     * @returns {Promise<{publicKey: string, privateKey: string}>} PEM格式的密钥字符串
-     */
-    static async generateKeyPair(modulusLength = 2048) {
-        const crypto = getCrypto();
-        try {
-            // 生成密钥对
-            const keyPair = await crypto.subtle.generateKey({
-                name: "RSA-OAEP",
-                modulusLength,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-                hash: "SHA-256",
-            }, true, // 是否可导出
-            ["encrypt", "decrypt"]);
-            // 导出公钥为PEM格式字符串
-            const publicKeyDer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
-            const publicKeyPem = this.derToPem(publicKeyDer, 'PUBLIC');
-            // 导出私钥为PEM格式字符串
-            const privateKeyDer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
-            const privateKeyPem = this.derToPem(privateKeyDer, 'PRIVATE');
-            return {
-                publicKey: publicKeyPem,
-                privateKey: privateKeyPem
-            };
-        }
-        catch (error) {
-            throw new Error(`生成密钥对失败: ${error.message}`);
-        }
-    }
-    /**
-     * 使用公钥加密字符串
-     * @param {string} publicKeyPem - PEM格式的公钥字符串
-     * @param {string} data - 要加密的字符串数据
-     * @returns {Promise<string>} Base64编码的加密字符串
-     */
-    static async encrypt(publicKeyPem, data) {
-        const crypto = getCrypto();
-        try {
-            // 导入公钥
-            const publicKey = await this.importPublicKey(publicKeyPem);
-            // 转换数据为Uint8Array
-            const encoder = new TextEncoder();
-            const dataBuffer = encoder.encode(data);
-            // 检查数据长度（RSA-OAEP有最大长度限制）
-            const maxLength = this.getMaxEncryptLength(publicKeyPem);
-            if (dataBuffer.length > maxLength) {
-                throw new Error(`数据过长，最大支持${maxLength}字节，当前${dataBuffer.length}字节`);
-            }
-            // 加密数据
-            const encrypted = await crypto.subtle.encrypt({
-                name: "RSA-OAEP"
-            }, publicKey, dataBuffer);
-            // 转换为Base64字符串
-            return this.arrayBufferToBase64(encrypted);
-        }
-        catch (error) {
-            throw new Error(`加密失败: ${error.message}`);
-        }
-    }
-    /**
-     * 使用私钥解密字符串
-     * @param {string} privateKeyPem - PEM格式的私钥字符串
-     * @param {string} encryptedData - Base64编码的加密字符串
-     * @returns {Promise<string>} 解密后的原始字符串
-     */
-    static async decrypt(privateKeyPem, encryptedData) {
-        const crypto = getCrypto();
-        try {
-            // 导入私钥
-            const privateKey = await this.importPrivateKey(privateKeyPem);
-            // 转换Base64字符串为ArrayBuffer
-            const encryptedBuffer = this.base64ToArrayBuffer(encryptedData);
-            // 解密数据
-            const decrypted = await crypto.subtle.decrypt({
-                name: "RSA-OAEP"
-            }, privateKey, encryptedBuffer);
-            // 转换回字符串
-            const decoder = new TextDecoder();
-            return decoder.decode(decrypted);
-        }
-        catch (error) {
-            throw new Error(`解密失败: ${error.message}`);
-        }
-    }
-    /**
-     * 导入PEM格式的公钥字符串为CryptoKey对象
-     * @param {string} publicKeyPem - PEM格式的公钥字符串
-     * @returns {Promise<CryptoKey>}
-     */
-    static async importPublicKey(publicKeyPem) {
-        const crypto = getCrypto();
-        try {
-            // PEM转DER
-            const der = this.pemToDer(publicKeyPem);
-            // 导入密钥
-            return await crypto.subtle.importKey("spki", der, {
-                name: "RSA-OAEP",
-                hash: "SHA-256"
-            }, true, ["encrypt"]);
-        }
-        catch (error) {
-            throw new Error(`导入公钥失败: ${error.message}`);
-        }
-    }
-    /**
-     * 导入PEM格式的私钥字符串为CryptoKey对象
-     * @param {string} privateKeyPem - PEM格式的私钥字符串
-     * @returns {Promise<CryptoKey>}
-     */
-    static async importPrivateKey(privateKeyPem) {
-        const crypto = getCrypto();
-        try {
-            // PEM转DER
-            const der = this.pemToDer(privateKeyPem);
-            // 导入密钥
-            return await crypto.subtle.importKey("pkcs8", der, {
-                name: "RSA-OAEP",
-                hash: "SHA-256"
-            }, true, ["decrypt"]);
-        }
-        catch (error) {
-            throw new Error(`导入私钥失败: ${error.message}`);
-        }
-    }
-    /**
-     * 获取公钥支持的最大加密长度（字节数）
-     * @param {string} publicKeyPem - PEM格式的公钥字符串
-     * @returns {number} 最大加密字节数
-     */
-    static getMaxEncryptLength(publicKeyPem) {
-        // 简单估算最大加密长度
-        // RSA-OAEP最大加密长度 = modulusLength/8 - 2*hashLength/8 - 2
-        // 这里通过PEM字符串长度来估算密钥长度
-        // 提取Base64内容
-        const base64Data = publicKeyPem
-            .replace(/-----BEGIN PUBLIC KEY-----/, '')
-            .replace(/-----END PUBLIC KEY-----/, '')
-            .replace(/\s+/g, '');
-        // Base64解码获取DER长度
-        const derLength = atob(base64Data).length;
-        // 典型长度对应关系：
-        if (derLength <= 294) { // 2048位密钥DER长度约294字节
-            return 190; // 2048位：190字节
-        }
-        else if (derLength <= 422) { // 3072位密钥DER长度约422字节
-            return 318; // 3072位：318字节
-        }
-        else { // 4096位
-            return 446; // 4096位：446字节
-        }
-    }
-    /**
-     * 将DER格式转换为PEM格式字符串
-     * @param {ArrayBuffer} der - DER格式的密钥数据
-     * @param {string} type - 密钥类型 ('PUBLIC' 或 'PRIVATE')
-     * @returns {string} PEM格式的密钥字符串
-     */
-    static derToPem(der, type) {
-        const base64 = this.arrayBufferToBase64(der);
-        // 将Base64字符串分割为64字符一行
-        const wrapped = base64.match(/.{1,64}/g).join('\n');
-        if (type === 'PUBLIC') {
-            return `-----BEGIN PUBLIC KEY-----\n${wrapped}\n-----END PUBLIC KEY-----`;
-        }
-        else {
-            return `-----BEGIN PRIVATE KEY-----\n${wrapped}\n-----END PRIVATE KEY-----`;
-        }
-    }
-    /**
-     * 将PEM格式字符串转换为DER格式
-     * @param {string} pem - PEM格式的密钥字符串
-     * @returns {ArrayBuffer} DER格式的密钥数据
-     */
-    static pemToDer(pem) {
-        // 移除PEM头部、尾部和所有空白字符
-        const base64 = pem
-            .replace(/-----BEGIN (?:PUBLIC|PRIVATE) KEY-----/, '')
-            .replace(/-----END (?:PUBLIC|PRIVATE) KEY-----/, '')
-            .replace(/\s+/g, '');
-        return this.base64ToArrayBuffer(base64);
-    }
-    /**
-     * ArrayBuffer转Base64字符串
-     * @param {ArrayBuffer} buffer
-     * @returns {string}
-     */
-    static arrayBufferToBase64(buffer) {
-        const bytes = new Uint8Array(buffer);
-        let binary = '';
-        for (let i = 0; i < bytes.byteLength; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    /**
-     * Base64字符串转ArrayBuffer
-     * @param {string} base64
-     * @returns {ArrayBuffer}
-     */
-    static base64ToArrayBuffer(base64) {
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        return bytes.buffer;
-    }
-    /**
-     * 验证PEM格式的密钥字符串
-     * @param {string} pem - PEM格式的密钥字符串
-     * @param {'PUBLIC'|'PRIVATE'} expectedType - 期望的密钥类型
-     * @returns {boolean} 是否为有效的PEM格式
-     */
-    static validatePemFormat(pem, expectedType) {
-        if (typeof pem !== 'string')
-            return false;
-        const publicKeyPattern = /^-----BEGIN PUBLIC KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PUBLIC KEY-----$/;
-        const privateKeyPattern = /^-----BEGIN PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PRIVATE KEY-----$/;
-        if (expectedType === 'PUBLIC') {
-            return publicKeyPattern.test(pem);
-        }
-        else {
-            return privateKeyPattern.test(pem);
-        }
-    }
-}
-exports.AsymmetricCrypto = AsymmetricCrypto;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsymmetricCrypto = void 0;
+function getCrypto() {
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        // 浏览器环境或Node.js 19+的global.crypto
+        return crypto;
+    }
+    else if (typeof global !== 'undefined') {
+        // Node.js环境
+        if (global.crypto && global.crypto.subtle) {
+            // Node.js 19+
+            return global.crypto;
+        }
+        // @ts-ignore
+        else if (global.crypto && global.crypto.webcrypto && global.crypto.webcrypto.subtle) {
+            // Node.js 16+
+            // @ts-ignore
+            return global.crypto.webcrypto;
+        }
+        else {
+            // Node.js 16-18，使用crypto.webcrypto
+            const nodeCrypto = require('crypto');
+            if (nodeCrypto.webcrypto && nodeCrypto.webcrypto.subtle) {
+                return nodeCrypto.webcrypto;
+            }
+            throw new Error('Node.js版本低于16或缺少webcrypto支持');
+        }
+    }
+    throw new Error('当前环境不支持Web Crypto API');
+}
+class AsymmetricCrypto {
+    /**
+     * 生成RSA密钥对并返回字符串格式的公钥和私钥
+     * @param {number} modulusLength - 密钥长度，默认2048
+     * @returns {Promise<{publicKey: string, privateKey: string}>} PEM格式的密钥字符串
+     */
+    static async generateKeyPair(modulusLength = 2048) {
+        const crypto = getCrypto();
+        try {
+            // 生成密钥对
+            const keyPair = await crypto.subtle.generateKey({
+                name: "RSA-OAEP",
+                modulusLength,
+                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                hash: "SHA-256",
+            }, true, // 是否可导出
+            ["encrypt", "decrypt"]);
+            // 导出公钥为PEM格式字符串
+            const publicKeyDer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+            const publicKeyPem = this.derToPem(publicKeyDer, 'PUBLIC');
+            // 导出私钥为PEM格式字符串
+            const privateKeyDer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+            const privateKeyPem = this.derToPem(privateKeyDer, 'PRIVATE');
+            return {
+                publicKey: publicKeyPem,
+                privateKey: privateKeyPem
+            };
+        }
+        catch (error) {
+            throw new Error(`生成密钥对失败: ${error.message}`);
+        }
+    }
+    /**
+     * 使用公钥加密字符串
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @param {string} data - 要加密的字符串数据
+     * @returns {Promise<string>} Base64编码的加密字符串
+     */
+    static async encrypt(publicKeyPem, data) {
+        const crypto = getCrypto();
+        try {
+            // 导入公钥
+            const publicKey = await this.importPublicKey(publicKeyPem);
+            // 转换数据为Uint8Array
+            const encoder = new TextEncoder();
+            const dataBuffer = encoder.encode(data);
+            // 检查数据长度（RSA-OAEP有最大长度限制）
+            const maxLength = this.getMaxEncryptLength(publicKeyPem);
+            if (dataBuffer.length > maxLength) {
+                throw new Error(`数据过长，最大支持${maxLength}字节，当前${dataBuffer.length}字节`);
+            }
+            // 加密数据
+            const encrypted = await crypto.subtle.encrypt({
+                name: "RSA-OAEP"
+            }, publicKey, dataBuffer);
+            // 转换为Base64字符串
+            return this.arrayBufferToBase64(encrypted);
+        }
+        catch (error) {
+            throw new Error(`加密失败: ${error.message}`);
+        }
+    }
+    /**
+     * 使用私钥解密字符串
+     * @param {string} privateKeyPem - PEM格式的私钥字符串
+     * @param {string} encryptedData - Base64编码的加密字符串
+     * @returns {Promise<string>} 解密后的原始字符串
+     */
+    static async decrypt(privateKeyPem, encryptedData) {
+        const crypto = getCrypto();
+        try {
+            // 导入私钥
+            const privateKey = await this.importPrivateKey(privateKeyPem);
+            // 转换Base64字符串为ArrayBuffer
+            const encryptedBuffer = this.base64ToArrayBuffer(encryptedData);
+            // 解密数据
+            const decrypted = await crypto.subtle.decrypt({
+                name: "RSA-OAEP"
+            }, privateKey, encryptedBuffer);
+            // 转换回字符串
+            const decoder = new TextDecoder();
+            return decoder.decode(decrypted);
+        }
+        catch (error) {
+            throw new Error(`解密失败: ${error.message}`);
+        }
+    }
+    /**
+     * 导入PEM格式的公钥字符串为CryptoKey对象
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @returns {Promise<CryptoKey>}
+     */
+    static async importPublicKey(publicKeyPem) {
+        const crypto = getCrypto();
+        try {
+            // PEM转DER
+            const der = this.pemToDer(publicKeyPem);
+            // 导入密钥
+            return await crypto.subtle.importKey("spki", der, {
+                name: "RSA-OAEP",
+                hash: "SHA-256"
+            }, true, ["encrypt"]);
+        }
+        catch (error) {
+            throw new Error(`导入公钥失败: ${error.message}`);
+        }
+    }
+    /**
+     * 导入PEM格式的私钥字符串为CryptoKey对象
+     * @param {string} privateKeyPem - PEM格式的私钥字符串
+     * @returns {Promise<CryptoKey>}
+     */
+    static async importPrivateKey(privateKeyPem) {
+        const crypto = getCrypto();
+        try {
+            // PEM转DER
+            const der = this.pemToDer(privateKeyPem);
+            // 导入密钥
+            return await crypto.subtle.importKey("pkcs8", der, {
+                name: "RSA-OAEP",
+                hash: "SHA-256"
+            }, true, ["decrypt"]);
+        }
+        catch (error) {
+            throw new Error(`导入私钥失败: ${error.message}`);
+        }
+    }
+    /**
+     * 获取公钥支持的最大加密长度（字节数）
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @returns {number} 最大加密字节数
+     */
+    static getMaxEncryptLength(publicKeyPem) {
+        // 简单估算最大加密长度
+        // RSA-OAEP最大加密长度 = modulusLength/8 - 2*hashLength/8 - 2
+        // 这里通过PEM字符串长度来估算密钥长度
+        // 提取Base64内容
+        const base64Data = publicKeyPem
+            .replace(/-----BEGIN PUBLIC KEY-----/, '')
+            .replace(/-----END PUBLIC KEY-----/, '')
+            .replace(/\s+/g, '');
+        // Base64解码获取DER长度
+        const derLength = atob(base64Data).length;
+        // 典型长度对应关系：
+        if (derLength <= 294) { // 2048位密钥DER长度约294字节
+            return 190; // 2048位：190字节
+        }
+        else if (derLength <= 422) { // 3072位密钥DER长度约422字节
+            return 318; // 3072位：318字节
+        }
+        else { // 4096位
+            return 446; // 4096位：446字节
+        }
+    }
+    /**
+     * 将DER格式转换为PEM格式字符串
+     * @param {ArrayBuffer} der - DER格式的密钥数据
+     * @param {string} type - 密钥类型 ('PUBLIC' 或 'PRIVATE')
+     * @returns {string} PEM格式的密钥字符串
+     */
+    static derToPem(der, type) {
+        const base64 = this.arrayBufferToBase64(der);
+        // 将Base64字符串分割为64字符一行
+        const wrapped = base64.match(/.{1,64}/g).join('\n');
+        if (type === 'PUBLIC') {
+            return `-----BEGIN PUBLIC KEY-----\n${wrapped}\n-----END PUBLIC KEY-----`;
+        }
+        else {
+            return `-----BEGIN PRIVATE KEY-----\n${wrapped}\n-----END PRIVATE KEY-----`;
+        }
+    }
+    /**
+     * 将PEM格式字符串转换为DER格式
+     * @param {string} pem - PEM格式的密钥字符串
+     * @returns {ArrayBuffer} DER格式的密钥数据
+     */
+    static pemToDer(pem) {
+        // 移除PEM头部、尾部和所有空白字符
+        const base64 = pem
+            .replace(/-----BEGIN (?:PUBLIC|PRIVATE) KEY-----/, '')
+            .replace(/-----END (?:PUBLIC|PRIVATE) KEY-----/, '')
+            .replace(/\s+/g, '');
+        return this.base64ToArrayBuffer(base64);
+    }
+    /**
+     * ArrayBuffer转Base64字符串
+     * @param {ArrayBuffer} buffer
+     * @returns {string}
+     */
+    static arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Base64字符串转ArrayBuffer
+     * @param {string} base64
+     * @returns {ArrayBuffer}
+     */
+    static base64ToArrayBuffer(base64) {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    /**
+     * 验证PEM格式的密钥字符串
+     * @param {string} pem - PEM格式的密钥字符串
+     * @param {'PUBLIC'|'PRIVATE'} expectedType - 期望的密钥类型
+     * @returns {boolean} 是否为有效的PEM格式
+     */
+    static validatePemFormat(pem, expectedType) {
+        if (typeof pem !== 'string')
+            return false;
+        const publicKeyPattern = /^-----BEGIN PUBLIC KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PUBLIC KEY-----$/;
+        const privateKeyPattern = /^-----BEGIN PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PRIVATE KEY-----$/;
+        if (expectedType === 'PUBLIC') {
+            return publicKeyPattern.test(pem);
+        }
+        else {
+            return privateKeyPattern.test(pem);
+        }
+    }
+}
+exports.AsymmetricCrypto = AsymmetricCrypto;

package/dist/libs/utils/base64.d.ts

@@ -1,9 +1,9 @@
-declare function toBase64(obj: any): string;
-/**
- * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
- * @param base64Str - 经 toBase64 处理后的 Base64 字符串
- * @returns 还原后的 JS 对象
- * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
- */
-declare function fromBase64(base64Str: string): any;
-export { toBase64, fromBase64 };
+declare function toBase64(obj: any): string;
+/**
+ * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
+ * @param base64Str - 经 toBase64 处理后的 Base64 字符串
+ * @returns 还原后的 JS 对象
+ * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
+ */
+declare function fromBase64(base64Str: string): any;
+export { toBase64, fromBase64 };

package/dist/libs/utils/base64.js

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromBase64 = exports.toBase64 = void 0;
-function toBase64(obj) {
-    const jsonString = JSON.stringify(obj);
-    return Buffer.from(jsonString, 'utf8').toString('base64');
-}
-exports.toBase64 = toBase64;
-/**
- * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
- * @param base64Str - 经 toBase64 处理后的 Base64 字符串
- * @returns 还原后的 JS 对象
- * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
- */
-function fromBase64(base64Str) {
-    // 校验输入是否为字符串
-    if (typeof base64Str !== 'string') {
-        throw new Error('input must Base64 string');
-    }
-    try {
-        // 1. 反向步骤1：将 Base64 字符串解码为 UTF-8 格式的 JSON 字符串
-        // 对应原函数的 Buffer.from(jsonString, 'utf8') 反向操作
-        const jsonString = Buffer.from(base64Str, 'base64').toString('utf8');
-        // 2. 反向步骤2：将 JSON 字符串解析为 JS 对象
-        // 对应原函数的 JSON.stringify(obj) 反向操作
-        const restoredObj = JSON.parse(jsonString);
-        return restoredObj;
-    }
-    catch (error) {
-        // 分类处理不同错误类型，提供明确提示
-        if (error instanceof TypeError && error.message.includes('invalid base64')) {
-            throw new Error('还原失败：输入不是有效的 Base64 字符串');
-        }
-        else if (error instanceof SyntaxError && error.message.includes('JSON')) {
-            throw new Error('还原失败：解码后的内容不是有效的 JSON 格式');
-        }
-        else {
-            throw new Error(`还原失败：未知错误 - ${error.message}`);
-        }
-    }
-}
-exports.fromBase64 = fromBase64;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = exports.toBase64 = void 0;
+function toBase64(obj) {
+    const jsonString = JSON.stringify(obj);
+    return Buffer.from(jsonString, 'utf8').toString('base64');
+}
+exports.toBase64 = toBase64;
+/**
+ * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
+ * @param base64Str - 经 toBase64 处理后的 Base64 字符串
+ * @returns 还原后的 JS 对象
+ * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
+ */
+function fromBase64(base64Str) {
+    // 校验输入是否为字符串
+    if (typeof base64Str !== 'string') {
+        throw new Error('input must Base64 string');
+    }
+    try {
+        // 1. 反向步骤1：将 Base64 字符串解码为 UTF-8 格式的 JSON 字符串
+        // 对应原函数的 Buffer.from(jsonString, 'utf8') 反向操作
+        const jsonString = Buffer.from(base64Str, 'base64').toString('utf8');
+        // 2. 反向步骤2：将 JSON 字符串解析为 JS 对象
+        // 对应原函数的 JSON.stringify(obj) 反向操作
+        const restoredObj = JSON.parse(jsonString);
+        return restoredObj;
+    }
+    catch (error) {
+        // 分类处理不同错误类型，提供明确提示
+        if (error instanceof TypeError && error.message.includes('invalid base64')) {
+            throw new Error('还原失败：输入不是有效的 Base64 字符串');
+        }
+        else if (error instanceof SyntaxError && error.message.includes('JSON')) {
+            throw new Error('还原失败：解码后的内容不是有效的 JSON 格式');
+        }
+        else {
+            throw new Error(`还原失败：未知错误 - ${error.message}`);
+        }
+    }
+}
+exports.fromBase64 = fromBase64;