web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/util/BrowserLineReader.js

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * 浏览器环境的行读取器
+ * 实现类似Go bufio.Reader的行读取功能
+ */
+class BrowserLineReader {
+  constructor(text) {
+    Object.defineProperty(this, "text", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "position", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "lines", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "currentLine", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.text = text;
+    this.position = 0;
+    this.lines = text.split(/\r?\n/);
+    this.currentLine = 0;
+  }
+  /**
+   * 读取一行，模拟Go的bufio.Reader.ReadLine()
+   * @returns {{line: Uint8Array, isPrefix: boolean, error: Error|null}} 读取结果
+   */
+  readLine() {
+    if (this.currentLine >= this.lines.length) {
+      return {
+        line: new Uint8Array(0),
+        isPrefix: false,
+        error: new Error('EOF')
+      };
+    }
+    const line = this.lines[this.currentLine];
+    this.currentLine++;
+    // 将字符串转换为Uint8Array (类似Go的[]byte)  
+    const encoder = new TextEncoder();
+    const lineBytes = encoder.encode(line);
+    // 这里简化了，假设单次可以读完整行  
+    return {
+      line: lineBytes,
+      isPrefix: false,
+      error: null
+    };
+  }
+}
+/**
+ * 从Reader中读取完整行
+ * @param {BrowserLineReader} reader - 行读取器
+ * @returns {{line: Uint8Array, error: Error|null}} 读取结果
+ */
+function readLine(reader) {
+  let ln = new Uint8Array(0);
+  let isPrefix = true;
+  let error = null;
+  while (isPrefix && error === null) {
+    const result = reader.readLine();
+    // 更新变量  
+    isPrefix = result.isPrefix;
+    error = result.error;
+    if (result.line.length > 0) {
+      // 合并数组 (类似Go的append)  
+      const newArray = new Uint8Array(ln.length + result.line.length);
+      newArray.set(ln);
+      newArray.set(result.line, ln.length);
+      ln = newArray;
+    }
+  }
+  return {
+    line: ln,
+    error
+  };
+}
+
+exports.BrowserLineReader = BrowserLineReader;
+exports.readLine = readLine;

package/dist/cjs/util/bcrypt.js

@@ -0,0 +1,115 @@
+'use strict';
+
+var block = require('../common/blowfish/block.js');
+var cipher = require('../common/blowfish/cipher.js');
+
+/**
+ * bcrypt password hashing implementation for browsers
+ * Compatible with Go's bcrypt implementation
+ */
+// 导入Blowfish实现    
+const majorVersion = '2';
+const minorVersion = 'a';
+const maxCryptedHashSize = 23;
+// Magic cipher data - 与Go实现保持一致  
+const magicCipherData = new Uint8Array([0x4f, 0x72, 0x70, 0x68, 0x65, 0x61, 0x6e, 0x42, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x53, 0x63, 0x72, 0x79, 0x44, 0x6f, 0x75, 0x62, 0x74]);
+// bcrypt使用的特殊base64字母表  
+const bcryptAlphabet = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+/**
+ * 自定义base64编码函数，匹配bcrypt的编码方式
+ */
+function base64Encode(data) {
+  let output = '';
+  let i = 0;
+  while (i < data.length) {
+    let a = i < data.length ? data[i++] : 0;
+    let b = i < data.length ? data[i++] : 0;
+    let c = i < data.length ? data[i++] : 0;
+    const triple = (a << 16) + (b << 8) + c;
+    output += bcryptAlphabet[triple >> 18 & 0x3F];
+    output += bcryptAlphabet[triple >> 12 & 0x3F];
+    output += bcryptAlphabet[triple >> 6 & 0x3F];
+    output += bcryptAlphabet[triple & 0x3F];
+  }
+  // 处理填充  
+  const mod = data.length % 3;
+  if (mod === 1) {
+    output = output.slice(0, -2);
+  } else if (mod === 2) {
+    output = output.slice(0, -1);
+  }
+  return new TextEncoder().encode(output);
+}
+/**
+ * 自定义base64解码函数，匹配bcrypt的解码方式
+ */
+function base64Decode(data) {
+  const input = new TextDecoder().decode(data);
+  const output = new Uint8Array(Math.floor(input.length * 3 / 4));
+  let outputIndex = 0;
+  const getBcryptValue = char => {
+    const index = bcryptAlphabet.indexOf(char);
+    if (index === -1) {
+      throw new Error('Invalid character in input');
+    }
+    return index;
+  };
+  for (let i = 0; i < input.length; i += 4) {
+    const a = getBcryptValue(input[i]);
+    const b = getBcryptValue(input[i + 1]);
+    const c = i + 2 < input.length ? getBcryptValue(input[i + 2]) : 0;
+    const d = i + 3 < input.length ? getBcryptValue(input[i + 3]) : 0;
+    const triple = a << 18 | b << 12 | c << 6 | d;
+    output[outputIndex++] = triple >> 16 & 0xFF;
+    if (i + 2 < input.length) output[outputIndex++] = triple >> 8 & 0xFF;
+    if (i + 3 < input.length) output[outputIndex++] = triple & 0xFF;
+  }
+  return output.slice(0, outputIndex);
+}
+/**
+ * Blowfish加密设置
+ */
+async function expensiveBlowfishSetup(key, cost, salt) {
+  const csalt = base64Decode(salt);
+  const ckey = new Uint8Array([...key, 0]);
+  const cipher$1 = cipher.newSaltedCipher(ckey, csalt);
+  const rounds = 1 << cost;
+  for (let i = 0; i < rounds; i++) {
+    block.expandKey(ckey, cipher$1);
+    block.expandKey(csalt, cipher$1);
+  }
+  return cipher$1;
+}
+/**
+ * bcrypt核心加密函数
+ */
+async function bcrypt(password, cost, salt) {
+  const cipherData = new Uint8Array(magicCipherData);
+  const cipher$1 = await expensiveBlowfishSetup(password, cost, salt);
+  for (let i = 0; i < 24; i += 8) {
+    for (let j = 0; j < 64; j++) {
+      const block = cipherData.slice(i, i + 8);
+      const destBlock = new Uint8Array(cipher.BlockSize);
+      cipher$1.encrypt(destBlock, block);
+      cipherData.set(destBlock, i);
+    }
+  }
+  return base64Encode(cipherData.slice(0, maxCryptedHashSize));
+}
+// 修改 generateFromPasswordWithSalt 函数返回完整的哈希信息  
+async function generateFromPasswordWithSalt(password, cost, unencodedSalt) {
+  if (unencodedSalt.length !== 16) {
+    throw new Error('Salt must be exactly 16 bytes');
+  }
+  const salt = base64Encode(unencodedSalt);
+  const hash = await bcrypt(password, cost, salt);
+  return {
+    hash,
+    salt: unencodedSalt,
+    cost,
+    major: majorVersion,
+    minor: minorVersion
+  };
+}
+
+exports.generateFromPasswordWithSalt = generateFromPasswordWithSalt;

package/dist/cjs/util/curve25519Encryption.js

@@ -0,0 +1,328 @@
+'use strict';
+
+var random = require('@stablelib/random');
+var tweetnacl = require('tweetnacl');
+var jsbn = require('jsbn');
+
+// import { webcrypto } from 'crypto'; 
+class Encryption {
+  static toHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+  }
+  // 将字节数组转换为BigInteger  
+  static bytesToBigInt(bytes) {
+    let hex = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+    return new jsbn.BigInteger(hex, 16);
+  }
+  // 将BigInteger转换为固定长度的字节数组  
+  static bigIntToBytes(bn, length) {
+    const hex = bn.toString(16).padStart(length * 2, '0');
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+      bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  // 扩展欧几里得算法计算模逆  
+  static extendedEuclidean(a, b) {
+    if (b.equals(jsbn.BigInteger.ZERO)) {
+      return [a, new jsbn.BigInteger("1"), new jsbn.BigInteger("0")];
+    }
+    const [gcd, x1, y1] = this.extendedEuclidean(b, a.mod(b));
+    const x = y1;
+    const y = x1.subtract(a.divide(b).multiply(y1));
+    return [gcd, x, y];
+  }
+  // 安全的模逆计算  
+  static safeModInverse(a, m) {
+    // 确保a为正数  
+    let positiveA = a.mod(m);
+    if (positiveA.compareTo(jsbn.BigInteger.ZERO) < 0) {
+      positiveA = positiveA.add(m);
+    }
+    // 计算GCD和模逆  
+    const [gcd, x] = this.extendedEuclidean(positiveA, m);
+    // 检查是否存在模逆  
+    if (!gcd.equals(new jsbn.BigInteger("1"))) {
+      throw new Error('Modular inverse does not exist');
+    }
+    // 确保结果为正数  
+    let result = x.mod(m);
+    if (result.compareTo(jsbn.BigInteger.ZERO) < 0) {
+      result = result.add(m);
+    }
+    return result;
+  }
+  // 修改转换函数中的模逆计算  
+  static ed25519PublicKeyToCurve25519(publicKey) {
+    // 1. 转换为big endian  
+    const bigEndianY = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      bigEndianY[31 - i] = publicKey[i];
+    }
+    // 2. 清除最高位  
+    bigEndianY[0] &= 127;
+    // 3. 转换为BigInteger并计算 u = (1 + y) / (1 - y)  
+    const y = this.bytesToBigInt(bigEndianY);
+    const one = new jsbn.BigInteger("1");
+    // 计算分子 (1 + y)  
+    const numerator = one.add(y);
+    // 计算分母 (1 - y)  
+    const denominator = one.subtract(y);
+    try {
+      // 使用新的安全模逆计算  
+      const denominatorInv = this.safeModInverse(denominator, this.CURVE25519_P);
+      // 计算 u  
+      let u = numerator.multiply(denominatorInv).mod(this.CURVE25519_P);
+      // 4. 转换回little endian  
+      const result = this.bigIntToBytes(u, 32);
+      const littleEndianResult = new Uint8Array(32);
+      for (let i = 0; i < 32; i++) {
+        littleEndianResult[i] = result[31 - i];
+      }
+      return littleEndianResult;
+    } catch (error) {
+      console.error('Error during conversion:', error);
+      throw error;
+    }
+  }
+  static async encrypt(recipientPublicKey, message) {
+    try {
+      if (recipientPublicKey.length !== this.PUBLIC_KEY_LENGTH) {
+        throw new Error(`Invalid public key length: ${recipientPublicKey.length}`);
+      }
+      const curve25519PublicKey = Encryption.ed25519PublicKeyToCurve25519(recipientPublicKey); //ed25519.getPublicKey(recipientPublicKey);  
+      const ephemeralKeyPair = tweetnacl.box.keyPair();
+      const nonce = random.randomBytes(this.NONCE_LENGTH);
+      const encrypted = tweetnacl.box(message, nonce, curve25519PublicKey, ephemeralKeyPair.secretKey);
+      if (!encrypted) {
+        throw new Error('Encryption failed');
+      }
+      const result = new Uint8Array(this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH + encrypted.length);
+      let offset = 0;
+      result.set(nonce, offset);
+      offset += this.NONCE_LENGTH;
+      result.set(ephemeralKeyPair.publicKey, offset);
+      offset += this.PUBLIC_KEY_LENGTH;
+      result.set(encrypted, offset);
+      return result;
+    } catch (error) {
+      throw new Error(`Encryption failed: ${error.message}`);
+    }
+  }
+  static async encryptWithDebug(recipientPublicKey, message) {
+    try {
+      console.log('\n=== Encryption Debug Information ===');
+      console.log('Input Data:');
+      console.log('- Message:', new TextDecoder().decode(message));
+      console.log('- Message (hex):', this.toHex(message));
+      console.log('- Recipient Public Key:', this.toHex(recipientPublicKey));
+      if (recipientPublicKey.length !== this.PUBLIC_KEY_LENGTH) {
+        throw new Error(`Invalid public key length: ${recipientPublicKey.length}`);
+      }
+      const curve25519PublicKey = Encryption.ed25519PublicKeyToCurve25519(recipientPublicKey);
+      console.log('\nKey Conversion:');
+      console.log('- Ed25519 Public Key:', this.toHex(recipientPublicKey));
+      console.log('- Curve25519 Public Key:', this.toHex(curve25519PublicKey));
+      const ephemeralKeyPair = tweetnacl.box.keyPair();
+      console.log('\nEphemeral Key Pair:');
+      console.log('- Public Key:', this.toHex(ephemeralKeyPair.publicKey));
+      console.log('- Secret Key:', this.toHex(ephemeralKeyPair.secretKey));
+      const nonce = random.randomBytes(this.NONCE_LENGTH);
+      console.log('\nNonce:');
+      console.log('- Value:', this.toHex(nonce));
+      console.log('- Length:', nonce.length);
+      const encrypted = tweetnacl.box(message, nonce, curve25519PublicKey, ephemeralKeyPair.secretKey);
+      if (!encrypted) {
+        throw new Error('Encryption failed');
+      }
+      console.log('\nEncrypted Data:');
+      console.log('- Length:', encrypted.length);
+      console.log('- Value:', this.toHex(encrypted));
+      const result = new Uint8Array(this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH + encrypted.length);
+      let offset = 0;
+      result.set(nonce, offset);
+      offset += this.NONCE_LENGTH;
+      result.set(ephemeralKeyPair.publicKey, offset);
+      offset += this.PUBLIC_KEY_LENGTH;
+      result.set(encrypted, offset);
+      console.log('\nFinal Result:');
+      console.log('- Total Length:', result.length);
+      console.log('- Structure:');
+      console.log(`  * Nonce (${this.NONCE_LENGTH} bytes):`, this.toHex(result.slice(0, this.NONCE_LENGTH)));
+      console.log(`  * Ephemeral Public Key (${this.PUBLIC_KEY_LENGTH} bytes):`, this.toHex(result.slice(this.NONCE_LENGTH, this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH)));
+      console.log(`  * Encrypted Data (${encrypted.length} bytes):`, this.toHex(result.slice(this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH)));
+      console.log('- Complete Data:', this.toHex(result));
+      return result;
+    } catch (error) {
+      console.error('Encryption Debug Error:', error);
+      throw error;
+    }
+  }
+  //使用 Web Crypto API 实现 SHA-512  
+  static async sha512Hash(data) {
+    try {
+      // 优先使用 Web Crypto API  
+      if (typeof window !== 'undefined' && window.crypto) {
+        const buffer = await window.crypto.subtle.digest('SHA-512', data);
+        return new Uint8Array(buffer);
+      }
+      // // Node.js 环境  
+      // else if (typeof webcrypto !== 'undefined') {  
+      //     const buffer = await webcrypto.subtle.digest('SHA-512', data);  
+      //     return new Uint8Array(buffer);  
+      // }  
+      throw new Error('No crypto implementation available');
+    } catch (error) {
+      console.error('SHA-512 hash failed:', error);
+      throw error;
+    }
+  }
+  static async ed25519PrivateKeyToCurve25519(privateKey) {
+    // 使用新的 SHA-512 实现  
+    const h = await this.sha512Hash(privateKey.slice(0, 32));
+    // 清除特定位  
+    const result = new Uint8Array(h);
+    result[0] &= 248; // Clear bits 0,1,2  
+    result[31] &= 127; // Clear bit 7  
+    result[31] |= 64; // Set bit 6  
+    // 只使用前32字节  
+    const curve25519PrivateKey = result.slice(0, 32);
+    return curve25519PrivateKey;
+  }
+  static async decrypt(recipientPrivateKey, encryptedData) {
+    let debug = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    try {
+      if (debug) {
+        console.log('\n=== Starting Decryption Process ===');
+        console.log('Input Private Key:', this.toHex(recipientPrivateKey));
+        console.log('Encrypted Data Length:', encryptedData.length);
+        console.log('Encrypted Data:', this.toHex(encryptedData));
+      }
+      // 验证输入数据长度  
+      const minLength = this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH + this.MAC_LENGTH;
+      if (encryptedData.length < minLength) {
+        throw new Error(`Invalid encrypted data length: ${encryptedData.length} < ${minLength}`);
+      }
+      // 解析加密数据的各个部分  
+      const nonce = encryptedData.slice(0, this.NONCE_LENGTH);
+      const ephemeralPublicKey = encryptedData.slice(this.NONCE_LENGTH, this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH);
+      const ciphertext = encryptedData.slice(this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH);
+      if (debug) {
+        console.log('\n--- Parsed Components ---');
+        console.log('Nonce:', this.toHex(nonce));
+        console.log('Ephemeral Public Key:', this.toHex(ephemeralPublicKey));
+        console.log('Ciphertext:', this.toHex(ciphertext));
+      }
+      // 转换私钥（现在是异步的）  
+      const curve25519PrivateKey = await this.ed25519PrivateKeyToCurve25519(recipientPrivateKey);
+      if (debug) {
+        console.log('\n--- Key Conversion ---');
+        console.log('Original Ed25519 Private Key:', this.toHex(recipientPrivateKey));
+        console.log('Converted Curve25519 Private Key:', this.toHex(curve25519PrivateKey));
+      }
+      // 计算共享密钥  
+      const sharedKey = tweetnacl.box.before(ephemeralPublicKey, curve25519PrivateKey);
+      if (!sharedKey) {
+        throw new Error('Failed to compute shared key');
+      }
+      if (debug) {
+        console.log('\n--- Shared Key Computation ---');
+        console.log('Computed Shared Key:', this.toHex(sharedKey));
+      }
+      // 解密数据  
+      const decrypted = tweetnacl.box.open.after(ciphertext, nonce, sharedKey);
+      if (!decrypted) {
+        throw new Error('Decryption failed - invalid MAC');
+      }
+      if (debug) {
+        console.log('\n--- Decryption Result ---');
+        console.log('Decrypted Data Length:', decrypted.length);
+        console.log('Decrypted Data:', this.toHex(decrypted));
+        try {
+          console.log('Decrypted Text:', new TextDecoder().decode(decrypted));
+        } catch (e) {
+          console.log('(Binary data - could not decode as text)');
+        }
+      }
+      return decrypted;
+    } catch (error) {
+      console.error('Decryption error:', error);
+      throw new Error(`Decryption failed: ${error.message}`);
+    }
+  }
+  // 新增：解密调试辅助方法  
+  static async debugDecryptionProcess(recipientPrivateKey, encryptedData) {
+    console.log('\n======= Decryption Debug Process =======');
+    // 1. 输入验证  
+    console.log('\n=== Input Validation ===');
+    console.log('Private Key Length:', recipientPrivateKey.length);
+    console.log('Encrypted Data Length:', encryptedData.length);
+    // 2. 数据结构分析  
+    const structure = {
+      nonce: encryptedData.slice(0, this.NONCE_LENGTH),
+      ephemeralPublicKey: encryptedData.slice(this.NONCE_LENGTH, this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH),
+      ciphertext: encryptedData.slice(this.NONCE_LENGTH + this.PUBLIC_KEY_LENGTH)
+    };
+    console.log('\n=== Data Structure Analysis ===');
+    Object.entries(structure).forEach(_ref => {
+      let [key, value] = _ref;
+      console.log(`${key}:`);
+      console.log(`  Length: ${value.length}`);
+      console.log(`  Hex: ${this.toHex(value)}`);
+    });
+    // 3. 私钥转换过程  
+    console.log('\n=== Private Key Conversion ===');
+    try {
+      const curve25519PrivateKey = await this.ed25519PrivateKeyToCurve25519(recipientPrivateKey);
+      console.log('Conversion successful');
+      console.log('Converted Key:', this.toHex(curve25519PrivateKey));
+    } catch (error) {
+      console.error('Private key conversion failed:', error);
+      return;
+    }
+    // 4. 尝试解密  
+    console.log('\n=== Attempting Decryption ===');
+    try {
+      const decrypted = await this.decrypt(recipientPrivateKey, encryptedData, false);
+      console.log('Decryption successful');
+      console.log('Decrypted length:', decrypted.length);
+      console.log('Decrypted hex:', this.toHex(decrypted));
+      try {
+        const text = new TextDecoder().decode(decrypted);
+        console.log('Decrypted as text:', text);
+      } catch (e) {
+        console.log('(Data is not valid UTF-8 text)');
+      }
+    } catch (error) {
+      console.error('Decryption failed:', error);
+    }
+  }
+}
+Object.defineProperty(Encryption, "NONCE_LENGTH", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 24
+});
+Object.defineProperty(Encryption, "PUBLIC_KEY_LENGTH", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 32
+});
+Object.defineProperty(Encryption, "MAC_LENGTH", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 16
+});
+// Curve25519的素数  
+Object.defineProperty(Encryption, "CURVE25519_P", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: new jsbn.BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564819949")
+});
+
+exports.Encryption = Encryption;

package/dist/cjs/util/dccrypt.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var base32 = require('../node_modules/multiformats/dist/src/bases/base32.js');
+
+async function decryptContent(encryptBuffer, decryptKey) {
+  try {
+    if (decryptKey === "" || encryptBuffer.length <= 28) {
+      return encryptBuffer;
+    }
+    // 1. 准备数据  
+    const nonce = encryptBuffer.slice(0, 12);
+    // 尝试不同的密文分割方式  
+    const ciphertext = encryptBuffer.slice(12);
+    // 2. 准备密钥  
+    const inputKey = typeof decryptKey === "string" ? base32.base32.decode(decryptKey) : decryptKey;
+    // 3. 导入密钥  
+    const key = await window.crypto.subtle.importKey("raw", inputKey, {
+      name: "AES-GCM",
+      length: 256
+    }, false, ["decrypt"]);
+    // 4. 尝试不同的解密配置  
+    const configs = [{
+      tagLength: 128,
+      name: "标准模式"
+    }, {
+      tagLength: 96,
+      name: "96位标签模式"
+    }, {
+      tagLength: 64,
+      name: "64位标签模式"
+    }];
+    for (const config of configs) {
+      try {
+        const decrypted = await window.crypto.subtle.decrypt({
+          name: "AES-GCM",
+          iv: nonce,
+          tagLength: config.tagLength
+        }, key, ciphertext);
+        // 解密成功  
+        const result = new Uint8Array(decrypted);
+        return result;
+      } catch (e) {
+        console.log(`${config.name} 失败:`, e.message);
+        continue;
+      }
+    }
+    throw new Error('decrypt failed');
+  } catch (error) {
+    throw error;
+  }
+}
+
+exports.decryptContent = decryptContent;

package/dist/cjs/util/logger.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// util/logger.ts
+// 提供统一的日志接口
+/**
+ * 日志级别枚举
+ */
+exports.LogLevel = void 0;
+(function (LogLevel) {
+  LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+  LogLevel[LogLevel["INFO"] = 1] = "INFO";
+  LogLevel[LogLevel["WARN"] = 2] = "WARN";
+  LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(exports.LogLevel || (exports.LogLevel = {}));
+let globalConfig = {
+  level: exports.LogLevel.INFO,
+  enableTimestamp: true,
+  enableModuleName: true
+};
+/**
+ * 设置全局日志配置
+ * @param config 日志配置
+ */
+function configureLogger(config) {
+  globalConfig = {
+    ...globalConfig,
+    ...config
+  };
+}
+/**
+ * 创建日志记录器
+ * @param module 模块名称
+ * @returns 日志记录器对象
+ */
+function createLogger(module) {
+  return {
+    debug(message) {
+      if (globalConfig.level <= exports.LogLevel.DEBUG) {
+        const prefix = buildPrefix('DEBUG', module);
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        console.debug(prefix + message, ...args);
+      }
+    },
+    info(message) {
+      if (globalConfig.level <= exports.LogLevel.INFO) {
+        const prefix = buildPrefix('INFO', module);
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+        console.info(prefix + message, ...args);
+      }
+    },
+    warn(message) {
+      if (globalConfig.level <= exports.LogLevel.WARN) {
+        const prefix = buildPrefix('WARN', module);
+        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          args[_key3 - 1] = arguments[_key3];
+        }
+        console.warn(prefix + message, ...args);
+      }
+    },
+    error(message) {
+      if (globalConfig.level <= exports.LogLevel.ERROR) {
+        const prefix = buildPrefix('ERROR', module);
+        for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+          args[_key4 - 1] = arguments[_key4];
+        }
+        console.error(prefix + message, ...args);
+      }
+    }
+  };
+}
+/**
+ * 构建日志前缀
+ * @param level 日志级别
+ * @param module 模块名称
+ * @returns 格式化的前缀字符串
+ */
+function buildPrefix(level, module) {
+  let prefix = '';
+  if (globalConfig.enableTimestamp) {
+    prefix += `[${new Date().toISOString()}] `;
+  }
+  if (globalConfig.enableModuleName) {
+    prefix += `[${module}] `;
+  }
+  prefix += `[${level}] `;
+  return prefix;
+}
+
+exports.configureLogger = configureLogger;
+exports.createLogger = createLogger;