lakutata 0.0.1

package/build/chunk-DN5TSX6S.cjs

@@ -0,0 +1,244 @@
+'use strict';
+
+var chunkY7O5SCF6_cjs = require('./chunk-Y7O5SCF6.cjs');
+var chunkF5NKGQDL_cjs = require('./chunk-F5NKGQDL.cjs');
+var chunkTXTNUC7S_cjs = require('./chunk-TXTNUC7S.cjs');
+var chunkANDEVIKJ_cjs = require('./chunk-ANDEVIKJ.cjs');
+var chunkSEKBDIJH_cjs = require('./chunk-SEKBDIJH.cjs');
+var chunkMNDBRDT2_cjs = require('./chunk-MNDBRDT2.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+var crypto = require('crypto');
+
+// src/lib/base/abstracts/SymmetricEncryption.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var SUPPORT_CIPHERS = crypto.getCiphers().map((value) => value.toUpperCase());
+var _SymmetricEncryption = class _SymmetricEncryption {
+  /**
+   * 加解密算法
+   * @protected
+   */
+  algorithm;
+  /**
+   * 加密分组大小
+   * @protected
+   */
+  blockSize = 16;
+  /**
+   * 加解密秘钥
+   * @protected
+   */
+  key;
+  /**
+   * 加解密向量
+   * @protected
+   */
+  iv;
+  /**
+   * 是否使用空向量(ECB模式)
+   * 允许则为ECB模式，否则为CBC模式
+   * @protected
+   */
+  allowNullIV;
+  /**
+   * 加密器
+   * @constructor
+   */
+  get Cipher() {
+    return this.cipherCreator();
+  }
+  /**
+   * 解密器
+   * @constructor
+   */
+  get Decipher() {
+    return this.decipherCreator();
+  }
+  /**
+   * 加密器创建函数
+   * @protected
+   */
+  cipherCreator;
+  /**
+   * 解密器创建函数
+   * @protected
+   */
+  decipherCreator;
+  /**
+   * 初始化加密器
+   * @param algorithm
+   * @param allowNullIV
+   * @param key
+   * @param iv
+   * @protected
+   */
+  initCipher(algorithm, allowNullIV, key, iv) {
+    const bytesKey = key === void 0 ? void 0 : typeof key === "string" ? Buffer.from(key, "hex") : key;
+    const bytesIV = iv === void 0 ? void 0 : typeof iv === "string" ? Buffer.from(iv, "hex") : iv;
+    this.key = bytesKey ? bytesKey : crypto.randomBytes(this.keyLength);
+    this.iv = bytesIV ? bytesIV : crypto.randomBytes(this.ivLength);
+    this.algorithm = algorithm;
+    this.allowNullIV = allowNullIV;
+    const { blockSize, cipherCreator, decipherCreator } = SUPPORT_CIPHERS.includes(this.algorithm.toUpperCase()) ? this.algorithmFoundInitializer() : this.algorithmNotFoundInitializer();
+    this.blockSize = blockSize;
+    this.cipherCreator = cipherCreator;
+    this.decipherCreator = decipherCreator;
+    const validateKeyLengthResult = this.validateKeyLength(this.key);
+    if (!validateKeyLengthResult.isValid)
+      throw new chunkY7O5SCF6_cjs.InvalidSymmetricCipherKeyLengthException(
+        "The key length should be {expectBytes} bytes ({expectBits}-bits), but the received key length is {receivedBytes} bytes ({receivedBits}-bits)",
+        {
+          expectBytes: validateKeyLengthResult.expectBytes,
+          expectBits: validateKeyLengthResult.expectBytes * 8,
+          receivedBytes: validateKeyLengthResult.receivedBytes,
+          receivedBits: validateKeyLengthResult.receivedBytes * 8
+        }
+      );
+    const validateIVLengthResult = this.validateIVLength(this.iv);
+    if (!validateIVLengthResult.isValid)
+      throw new chunkSEKBDIJH_cjs.InvalidSymmetricCipherIVLengthException(
+        "The IV length should be {expectBytes} bytes ({expectBits}-bits), but the received IV length is {receivedBytes} bytes ({receivedBits}-bits)",
+        {
+          expectBytes: validateIVLengthResult.expectBytes,
+          expectBits: validateIVLengthResult.expectBytes * 8,
+          receivedBytes: validateIVLengthResult.receivedBytes,
+          receivedBits: validateIVLengthResult.receivedBytes * 8
+        }
+      );
+  }
+  /**
+   * 当算法在运行环境原生支持时的初始化函数
+   * @protected
+   */
+  algorithmFoundInitializer() {
+    var _a;
+    let blockSize = (_a = crypto.getCipherInfo(this.algorithm)) == null ? void 0 : _a.blockSize;
+    blockSize = blockSize ? blockSize : this.blockSize;
+    return {
+      blockSize,
+      cipherCreator: () => crypto.createCipheriv(this.algorithm, this.key, this.allowNullIV ? null : this.iv),
+      decipherCreator: () => crypto.createDecipheriv(this.algorithm, this.key, this.allowNullIV ? null : this.iv)
+    };
+  }
+  /**
+   * 当算法在运行环境原生不支持时的初始化函数
+   * @protected
+   */
+  algorithmNotFoundInitializer() {
+    throw new chunkF5NKGQDL_cjs.NotSupportCipherException('The algorithm "{algorithm}" is not support', { algorithm: this.algorithm });
+  }
+  /**
+   * 验证key的长度
+   * @param key
+   * @protected
+   */
+  validateKeyLength(key) {
+    return {
+      isValid: key.length === this.keyLength,
+      expectBytes: this.keyLength,
+      receivedBytes: key.length
+    };
+  }
+  /**
+   * 验证iv向量的长度
+   * @param iv
+   * @protected
+   */
+  validateIVLength(iv) {
+    return {
+      isValid: iv.length === this.ivLength,
+      expectBytes: this.ivLength,
+      receivedBytes: iv.length
+    };
+  }
+  /**
+   * 加密消息
+   * @param message
+   */
+  encrypt(message) {
+    try {
+      const cipher = this.Cipher;
+      return `${cipher.update(message, "utf-8", "hex")}${cipher.final("hex")}`;
+    } catch (e) {
+      throw new chunkANDEVIKJ_cjs.SymmetricEncryptException(e);
+    }
+  }
+  /**
+   * 异步加密消息
+   * @param message
+   */
+  async encryptAsync(message) {
+    try {
+      return await new Promise((resolve, reject) => {
+        let cache = Buffer.from([]);
+        chunkMNDBRDT2_cjs.ConvertToStream(message).pipe(this.Cipher).on("data", (chunk) => cache = Buffer.concat([cache, chunk])).once("error", reject).once("end", () => resolve(cache.toString("hex")));
+      });
+    } catch (e) {
+      throw new chunkANDEVIKJ_cjs.SymmetricEncryptException(e);
+    }
+  }
+  /**
+   * 解密消息
+   * @param encryptedMessage
+   */
+  decrypt(encryptedMessage) {
+    try {
+      const decipher = this.Decipher;
+      return `${decipher.update(encryptedMessage, "hex", "utf-8")}${decipher.final("utf-8")}`;
+    } catch (e) {
+      throw new chunkTXTNUC7S_cjs.SymmetricDecryptException(e);
+    }
+  }
+  /**
+   * 异步解密消息
+   * @param encryptedMessage
+   */
+  async decryptAsync(encryptedMessage) {
+    try {
+      return await new Promise((resolve, reject) => {
+        const decipher = this.Decipher;
+        decipher.once("error", reject);
+        let chunkCache = "";
+        let decryptedMessage = "";
+        chunkMNDBRDT2_cjs.ConvertToStream(encryptedMessage).on("data", (chunk) => {
+          chunkCache += chunk;
+          if (chunkCache.length >= this.blockSize) {
+            decryptedMessage += decipher.update(chunkCache, "hex", "utf-8");
+            chunkCache = "";
+          }
+        }).once("error", reject).once("end", () => resolve(`${decryptedMessage}${decipher.update(chunkCache, "hex", "utf-8")}${decipher.final("utf-8")}`));
+      });
+    } catch (e) {
+      throw new chunkTXTNUC7S_cjs.SymmetricDecryptException(e);
+    }
+  }
+  /**
+   * 获取秘钥，Hex字符串格式
+   */
+  getKey() {
+    return this.key.toString("hex");
+  }
+  /**
+   * 获取向量，Hex字符串格式
+   */
+  getIV() {
+    return this.allowNullIV ? null : this.iv.toString("hex");
+  }
+  /**
+   * 生成随机秘钥，Hex字符串格式
+   */
+  static generateKey() {
+    return crypto.randomBytes(new this().keyLength).toString("hex");
+  }
+  /**
+   * 生成随机向量，Hex字符串格式
+   */
+  static generateIV() {
+    return crypto.randomBytes(new this().ivLength).toString("hex");
+  }
+};
+chunkGGY7LCMQ_cjs.__name(_SymmetricEncryption, "SymmetricEncryption");
+var SymmetricEncryption = _SymmetricEncryption;
+
+exports.SymmetricEncryption = SymmetricEncryption;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/base/abstracts/SymmetricEncryption.ts"],"names":[],"mappings":"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","sourcesContent":["import 'reflect-metadata'\nimport {Cipher, createCipheriv, createDecipheriv, Decipher, getCiphers, randomBytes, getCipherInfo} from 'crypto'\nimport {\n    InvalidSymmetricCipherKeyLengthException\n} from '../../../exceptions/crypto/symmetric/InvalidSymmetricCipherKeyLengthException.js'\nimport {\n    InvalidSymmetricCipherIVLengthException\n} from '../../../exceptions/crypto/symmetric/InvalidSymmetricCipherIVLengthException.js'\nimport {IConstructor} from '../../../interfaces/IConstructor.js'\nimport {ConvertToStream} from '../../../Utilities.js'\nimport {NotSupportCipherException} from '../../../exceptions/crypto/symmetric/NotSupportCipherException.js'\nimport {SymmetricDecryptException} from '../../../exceptions/crypto/symmetric/SymmetricDecryptException.js'\nimport {SymmetricEncryptException} from '../../../exceptions/crypto/symmetric/SymmetricEncryptException.js'\n\nconst SUPPORT_CIPHERS: string[] = getCiphers().map((value: string) => value.toUpperCase())\n\ninterface SymmetricEncryptionValidateKeyLengthResult {\n    isValid: boolean\n    expectBytes: number\n    receivedBytes: number\n}\n\ninterface SymmetricEncryptionValidateIVLengthResult {\n    isValid: boolean\n    expectBytes: number\n    receivedBytes: number\n}\n\nexport interface AlgorithmInitializer {\n    blockSize: number\n    cipherCreator: () => Cipher\n    decipherCreator: () => Decipher\n}\n\n/**\n * 同步加密抽象类\n */\nexport abstract class SymmetricEncryption {\n\n    /**\n     * 加解密算法\n     * @protected\n     */\n    protected algorithm: string\n\n    /**\n     * 加密分组大小\n     * @protected\n     */\n    protected blockSize: number = 16\n\n    /**\n     * 加解密秘钥\n     * @protected\n     */\n    protected key: Buffer\n\n    /**\n     * 加解密向量\n     * @protected\n     */\n    protected iv: Buffer\n\n    /**\n     * 是否使用空向量(ECB模式)\n     * 允许则为ECB模式，否则为CBC模式\n     * @protected\n     */\n    protected allowNullIV: boolean\n\n    /**\n     * 加解密秘钥长度，以Bytes为单位\n     * @protected\n     */\n    protected abstract readonly keyLength: number\n\n    /**\n     * 加解密向量长度，以Bytes为单位\n     * @protected\n     */\n    protected abstract readonly ivLength: number\n\n    /**\n     * 加密器\n     * @constructor\n     */\n    public get Cipher(): Cipher {\n        return this.cipherCreator()\n    }\n\n    /**\n     * 解密器\n     * @constructor\n     */\n    public get Decipher(): Decipher {\n        return this.decipherCreator()\n    }\n\n    /**\n     * 加密器创建函数\n     * @protected\n     */\n    protected cipherCreator: () => Cipher\n\n    /**\n     * 解密器创建函数\n     * @protected\n     */\n    protected decipherCreator: () => Decipher\n\n    /**\n     * 初始化加密器\n     * @param algorithm\n     * @param allowNullIV\n     * @param key\n     * @param iv\n     * @protected\n     */\n    protected initCipher(algorithm: string, allowNullIV: boolean, key?: Buffer | string, iv?: Buffer | string): void {\n        const bytesKey: Buffer | undefined = key === undefined ? undefined : ((typeof key === 'string') ? Buffer.from(key, 'hex') : key)\n        const bytesIV: Buffer | undefined = iv === undefined ? undefined : ((typeof iv === 'string') ? Buffer.from(iv, 'hex') : iv)\n        this.key = bytesKey ? bytesKey : randomBytes(this.keyLength)\n        this.iv = bytesIV ? bytesIV : randomBytes(this.ivLength)\n        this.algorithm = algorithm\n        this.allowNullIV = allowNullIV\n        const {blockSize, cipherCreator, decipherCreator} = SUPPORT_CIPHERS.includes(this.algorithm.toUpperCase()) ? this.algorithmFoundInitializer() : this.algorithmNotFoundInitializer()\n        this.blockSize = blockSize\n        this.cipherCreator = cipherCreator\n        this.decipherCreator = decipherCreator\n        const validateKeyLengthResult: SymmetricEncryptionValidateKeyLengthResult = this.validateKeyLength(this.key)\n        if (!validateKeyLengthResult.isValid) throw new InvalidSymmetricCipherKeyLengthException(\n            'The key length should be {expectBytes} bytes ({expectBits}-bits), but the received key length is {receivedBytes} bytes ({receivedBits}-bits)',\n            {\n                expectBytes: validateKeyLengthResult.expectBytes,\n                expectBits: validateKeyLengthResult.expectBytes * 8,\n                receivedBytes: validateKeyLengthResult.receivedBytes,\n                receivedBits: validateKeyLengthResult.receivedBytes * 8\n            })\n        const validateIVLengthResult: SymmetricEncryptionValidateIVLengthResult = this.validateIVLength(this.iv)\n        if (!validateIVLengthResult.isValid) throw new InvalidSymmetricCipherIVLengthException(\n            'The IV length should be {expectBytes} bytes ({expectBits}-bits), but the received IV length is {receivedBytes} bytes ({receivedBits}-bits)', {\n                expectBytes: validateIVLengthResult.expectBytes,\n                expectBits: validateIVLengthResult.expectBytes * 8,\n                receivedBytes: validateIVLengthResult.receivedBytes,\n                receivedBits: validateIVLengthResult.receivedBytes * 8\n            })\n    }\n\n    /**\n     * 当算法在运行环境原生支持时的初始化函数\n     * @protected\n     */\n    protected algorithmFoundInitializer(): AlgorithmInitializer {\n        let blockSize: number | undefined = getCipherInfo(this.algorithm)?.blockSize\n        blockSize = blockSize ? blockSize : this.blockSize\n        return {\n            blockSize: blockSize,\n            cipherCreator: () => createCipheriv(this.algorithm, this.key, this.allowNullIV ? null : this.iv),\n            decipherCreator: () => createDecipheriv(this.algorithm, this.key, this.allowNullIV ? null : this.iv)\n        }\n    }\n\n    /**\n     * 当算法在运行环境原生不支持时的初始化函数\n     * @protected\n     */\n    protected algorithmNotFoundInitializer(): AlgorithmInitializer {\n        throw new NotSupportCipherException('The algorithm \"{algorithm}\" is not support', {algorithm: this.algorithm})\n    }\n\n    /**\n     * 验证key的长度\n     * @param key\n     * @protected\n     */\n    protected validateKeyLength(key: Buffer): SymmetricEncryptionValidateKeyLengthResult {\n        return {\n            isValid: key.length === this.keyLength,\n            expectBytes: this.keyLength,\n            receivedBytes: key.length\n        }\n    }\n\n    /**\n     * 验证iv向量的长度\n     * @param iv\n     * @protected\n     */\n    protected validateIVLength(iv: Buffer): SymmetricEncryptionValidateIVLengthResult {\n        return {\n            isValid: iv.length === this.ivLength,\n            expectBytes: this.ivLength,\n            receivedBytes: iv.length\n        }\n    }\n\n    /**\n     * 加密消息\n     * @param message\n     */\n    public encrypt(message: string): string {\n        try {\n            const cipher: Cipher = this.Cipher\n            return `${cipher.update(message, 'utf-8', 'hex')}${cipher.final('hex')}`\n        } catch (e) {\n            throw new SymmetricEncryptException(<Error>e)\n        }\n    }\n\n    /**\n     * 异步加密消息\n     * @param message\n     */\n    public async encryptAsync(message: string): Promise<string> {\n        try {\n            return await new Promise((resolve, reject): void => {\n                let cache: Buffer = Buffer.from([])\n                ConvertToStream(message).pipe(this.Cipher)\n                    .on('data', (chunk: Buffer) => cache = Buffer.concat([cache, chunk]))\n                    .once('error', reject)\n                    .once('end', () => resolve(cache.toString('hex')))\n            })\n        } catch (e) {\n            throw new SymmetricEncryptException(<Error>e)\n        }\n    }\n\n    /**\n     * 解密消息\n     * @param encryptedMessage\n     */\n    public decrypt(encryptedMessage: string): string {\n        try {\n            const decipher: Decipher = this.Decipher\n            return `${decipher.update(encryptedMessage, 'hex', 'utf-8')}${decipher.final('utf-8')}`\n        } catch (e) {\n            throw new SymmetricDecryptException(<Error>e)\n        }\n    }\n\n    /**\n     * 异步解密消息\n     * @param encryptedMessage\n     */\n    public async decryptAsync(encryptedMessage: string): Promise<string> {\n        try {\n            return await new Promise((resolve, reject): void => {\n                const decipher: Decipher = this.Decipher\n                decipher.once('error', reject)\n                let chunkCache: string = ''\n                let decryptedMessage: string = ''\n                ConvertToStream(encryptedMessage)\n                    .on('data', (chunk: string) => {\n                        chunkCache += chunk\n                        if (chunkCache.length >= this.blockSize) {\n                            decryptedMessage += decipher.update(chunkCache, 'hex', 'utf-8')\n                            chunkCache = ''\n                        }\n                    })\n                    .once('error', reject)\n                    .once('end', () => resolve(`${decryptedMessage}${decipher.update(chunkCache, 'hex', 'utf-8')}${decipher.final('utf-8')}`))\n            })\n        } catch (e) {\n            throw new SymmetricDecryptException(<Error>e)\n        }\n    }\n\n    /**\n     * 获取秘钥，Hex字符串格式\n     */\n    public getKey(): string {\n        return this.key.toString('hex')\n    }\n\n    /**\n     * 获取向量，Hex字符串格式\n     */\n    public getIV(): string | null {\n        return this.allowNullIV ? null : this.iv.toString('hex')\n    }\n\n    /**\n     * 生成随机秘钥，Hex字符串格式\n     */\n    public static generateKey<T extends SymmetricEncryption>(this: IConstructor<T>): string {\n        return randomBytes(new this().keyLength).toString('hex')\n    }\n\n    /**\n     * 生成随机向量，Hex字符串格式\n     */\n    public static generateIV<T extends SymmetricEncryption>(this: IConstructor<T>): string {\n        return randomBytes(new this().ivLength).toString('hex')\n    }\n}\n"]}

package/build/chunk-EEH5LCBP.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkHBPRX3WA_cjs = require('./chunk-HBPRX3WA.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/exceptions/InvalidConfigurableValueException.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _InvalidConfigurableValueException = class _InvalidConfigurableValueException extends chunkHBPRX3WA_cjs.Exception {
+  errno = "E_INVALID_CONFIGURABLE_VALUE";
+};
+chunkGGY7LCMQ_cjs.__name(_InvalidConfigurableValueException, "InvalidConfigurableValueException");
+var InvalidConfigurableValueException = _InvalidConfigurableValueException;
+
+exports.InvalidConfigurableValueException = InvalidConfigurableValueException;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGNlcHRpb25zL0ludmFsaWRDb25maWd1cmFibGVWYWx1ZUV4Y2VwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTtBQUVPLElBQU0scUNBQU4sTUFBTSwyQ0FBMEMsVUFBVTtBQUFBLEVBQ3RELFFBQXlCO0FBQ3BDO0FBRmlFO0FBQTFELElBQU0sb0NBQU4iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0V4Y2VwdGlvbn0gZnJvbSAnLi4vbGliL2Jhc2UvYWJzdHJhY3RzL0V4Y2VwdGlvbi5qcydcblxuZXhwb3J0IGNsYXNzIEludmFsaWRDb25maWd1cmFibGVWYWx1ZUV4Y2VwdGlvbiBleHRlbmRzIEV4Y2VwdGlvbiB7XG4gICAgcHVibGljIGVycm5vOiBudW1iZXIgfCBzdHJpbmcgPSAnRV9JTlZBTElEX0NPTkZJR1VSQUJMRV9WQUxVRSdcbn1cbiJdfQ==

package/build/chunk-EFYDUUXT.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+var chunkN37KV2VV_cjs = require('./chunk-N37KV2VV.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/lib/ioc/ParamParser.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+function parseParameterList(source) {
+  const { next: _next, done } = chunkN37KV2VV_cjs.createTokenizer(source);
+  const params = [];
+  let t = null;
+  nextToken();
+  while (!done()) {
+    switch (t.type) {
+      case "class":
+        skipUntilConstructor();
+        if (!isConstructorToken())
+          return null;
+        nextToken();
+        break;
+      case "function":
+        const next = nextToken();
+        if (next.type === "ident" || next.type === "*")
+          nextToken();
+        break;
+      case "(":
+        parseParams();
+        break;
+      case ")":
+        return params;
+      case "ident":
+        const param = { name: t.value, optional: false };
+        if (t.value === "async") {
+          const next2 = nextToken();
+          if (next2 && next2.type !== "=") {
+            break;
+          }
+        }
+        params.push(param);
+        return params;
+      default:
+        throw unexpected();
+    }
+  }
+  return params;
+  function parseParams() {
+    let param = { name: "", optional: false };
+    while (!done()) {
+      nextToken();
+      switch (t.type) {
+        case "ident":
+          param.name = t.value;
+          break;
+        case "=":
+          param.optional = true;
+          break;
+        case ",":
+          params.push(param);
+          param = { name: "", optional: false };
+          break;
+        case ")":
+          if (param.name) {
+            params.push(param);
+          }
+          return;
+        default:
+          throw unexpected();
+      }
+    }
+  }
+  function skipUntilConstructor() {
+    while (!isConstructorToken() && !done())
+      nextToken(1 /* Dumb */);
+  }
+  function isConstructorToken() {
+    return t.type === "ident" && t.value === "constructor";
+  }
+  function nextToken(flags = 0 /* None */) {
+    t = _next(flags);
+    return t;
+  }
+  function unexpected() {
+    return new SyntaxError(
+      `Parsing parameter list, did not expect ${t.type} token${t.value ? ` (${t.value})` : ""}`
+    );
+  }
+}
+chunkGGY7LCMQ_cjs.__name(parseParameterList, "parseParameterList");
+
+exports.parseParameterList = parseParameterList;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-ENJSEFE4.js

@@ -0,0 +1,14 @@
+import { Exception } from './chunk-HODDA5D5.js';
+import { init_esm_shims, __name } from './chunk-5NK7E2HA.js';
+
+// src/exceptions/controller/NoMatchedControllerActionPatternException.ts
+init_esm_shims();
+var _NoMatchedControllerActionPatternException = class _NoMatchedControllerActionPatternException extends Exception {
+  errno = "E_NO_MATCHED_CONTROLLER_ACTION_PATTERN";
+};
+__name(_NoMatchedControllerActionPatternException, "NoMatchedControllerActionPatternException");
+var NoMatchedControllerActionPatternException = _NoMatchedControllerActionPatternException;
+
+export { NoMatchedControllerActionPatternException };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGNlcHRpb25zL2NvbnRyb2xsZXIvTm9NYXRjaGVkQ29udHJvbGxlckFjdGlvblBhdHRlcm5FeGNlcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUE7QUFFTyxJQUFNLDZDQUFOLE1BQU0sbURBQWtELFVBQVU7QUFBQSxFQUM5RCxRQUF5QjtBQUNwQztBQUZ5RTtBQUFsRSxJQUFNLDRDQUFOIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFeGNlcHRpb259IGZyb20gJy4uLy4uL2xpYi9iYXNlL2Fic3RyYWN0cy9FeGNlcHRpb24uanMnXG5cbmV4cG9ydCBjbGFzcyBOb01hdGNoZWRDb250cm9sbGVyQWN0aW9uUGF0dGVybkV4Y2VwdGlvbiBleHRlbmRzIEV4Y2VwdGlvbiB7XG4gICAgcHVibGljIGVycm5vOiBudW1iZXIgfCBzdHJpbmcgPSAnRV9OT19NQVRDSEVEX0NPTlRST0xMRVJfQUNUSU9OX1BBVFRFUk4nXG59XG4iXX0=

package/build/chunk-EPYJVQHQ.js

@@ -0,0 +1,6 @@
+import { init_esm_shims } from './chunk-5NK7E2HA.js';
+
+// src/types/TimeInput.ts
+init_esm_shims();
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90eXBlcy9UaW1lSW5wdXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VGltZX0gZnJvbSAnLi4vVGltZS5qcydcblxuZXhwb3J0IHR5cGUgVGltZUlucHV0ID0gVGltZSB8IERhdGUgfCBzdHJpbmcgfCBudW1iZXIgfCAobnVtYmVyIHwgc3RyaW5nKVtdIHwgbnVsbFxuIl19

package/build/chunk-EUVLTNDV.js

@@ -0,0 +1,32 @@
+import { require_browserify_cipher } from './chunk-I5TGKTX6.js';
+import { SymmetricEncryption } from './chunk-LJTCXKC4.js';
+import { init_esm_shims, __toESM, __name } from './chunk-5NK7E2HA.js';
+
+// src/lib/crypto/aes/AES256.ts
+init_esm_shims();
+var import_browserify_cipher = __toESM(require_browserify_cipher(), 1);
+var _AES256 = class _AES256 extends SymmetricEncryption {
+  ivLength = 16;
+  keyLength = 32;
+  constructor(key, iv) {
+    super();
+    if (!arguments.length)
+      return;
+    const allowNullIV = iv === void 0;
+    const algorithm = `aes-256-${allowNullIV ? "ecb" : "cbc"}`;
+    this.initCipher(algorithm, allowNullIV, key, iv);
+  }
+  algorithmNotFoundInitializer() {
+    return {
+      blockSize: 16,
+      cipherCreator: () => (0, import_browserify_cipher.createCipheriv)(this.algorithm, this.key, this.allowNullIV ? null : this.iv),
+      decipherCreator: () => (0, import_browserify_cipher.createDecipheriv)(this.algorithm, this.key, this.allowNullIV ? null : this.iv)
+    };
+  }
+};
+__name(_AES256, "AES256");
+var AES256 = _AES256;
+
+export { AES256 };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-EXQVCESB.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/lib/ioc/InjectionMode.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var InjectionMode = {
+  /**
+   * 依赖项将通过注入摇篮代理来解析
+   */
+  PROXY: "PROXY",
+  /**
+   * 依赖项将通过检查函数/构造函数的参数名称来解析
+   */
+  CLASSIC: "CLASSIC"
+};
+
+exports.InjectionMode = InjectionMode;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9saWIvaW9jL0luamVjdGlvbk1vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQVVPLElBQU0sZ0JBQThEO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFJdkUsT0FBTztBQUFBO0FBQUE7QUFBQTtBQUFBLEVBS1AsU0FBUztBQUNiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICdyZWZsZWN0LW1ldGFkYXRhJ1xuXG4vKipcbiAqIOazqOWFpeaooeW8j+exu+Wei1xuICovXG5leHBvcnQgdHlwZSBJbmplY3Rpb25Nb2RlVHlwZSA9ICdQUk9YWScgfCAnQ0xBU1NJQydcblxuLyoqXG4gKiDop6PmnpDmqKHlvI9cbiAqL1xuZXhwb3J0IGNvbnN0IEluamVjdGlvbk1vZGU6IFJlY29yZDxJbmplY3Rpb25Nb2RlVHlwZSwgSW5qZWN0aW9uTW9kZVR5cGU+ID0ge1xuICAgIC8qKlxuICAgICAqIOS+nei1lumhueWwhumAmui/h+azqOWFpeaRh+evruS7o+eQhuadpeino+aekFxuICAgICAqL1xuICAgIFBST1hZOiAnUFJPWFknLFxuXG4gICAgLyoqXG4gICAgICog5L6d6LWW6aG55bCG6YCa6L+H5qOA5p+l5Ye95pWwL+aehOmAoOWHveaVsOeahOWPguaVsOWQjeensOadpeino+aekFxuICAgICAqL1xuICAgIENMQVNTSUM6ICdDTEFTU0lDJ1xufVxuIl19

package/build/chunk-EYPPC6HP.js

@@ -0,0 +1,18 @@
+import { init_esm_shims } from './chunk-5NK7E2HA.js';
+
+// src/lib/ioc/InjectionMode.ts
+init_esm_shims();
+var InjectionMode = {
+  /**
+   * 依赖项将通过注入摇篮代理来解析
+   */
+  PROXY: "PROXY",
+  /**
+   * 依赖项将通过检查函数/构造函数的参数名称来解析
+   */
+  CLASSIC: "CLASSIC"
+};
+
+export { InjectionMode };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9saWIvaW9jL0luamVjdGlvbk1vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQVVPLElBQU0sZ0JBQThEO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFJdkUsT0FBTztBQUFBO0FBQUE7QUFBQTtBQUFBLEVBS1AsU0FBUztBQUNiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICdyZWZsZWN0LW1ldGFkYXRhJ1xuXG4vKipcbiAqIOazqOWFpeaooeW8j+exu+Wei1xuICovXG5leHBvcnQgdHlwZSBJbmplY3Rpb25Nb2RlVHlwZSA9ICdQUk9YWScgfCAnQ0xBU1NJQydcblxuLyoqXG4gKiDop6PmnpDmqKHlvI9cbiAqL1xuZXhwb3J0IGNvbnN0IEluamVjdGlvbk1vZGU6IFJlY29yZDxJbmplY3Rpb25Nb2RlVHlwZSwgSW5qZWN0aW9uTW9kZVR5cGU+ID0ge1xuICAgIC8qKlxuICAgICAqIOS+nei1lumhueWwhumAmui/h+azqOWFpeaRh+evruS7o+eQhuadpeino+aekFxuICAgICAqL1xuICAgIFBST1hZOiAnUFJPWFknLFxuXG4gICAgLyoqXG4gICAgICog5L6d6LWW6aG55bCG6YCa6L+H5qOA5p+l5Ye95pWwL+aehOmAoOWHveaVsOeahOWPguaVsOWQjeensOadpeino+aekFxuICAgICAqL1xuICAgIENMQVNTSUM6ICdDTEFTU0lDJ1xufVxuIl19

package/build/chunk-F5NKGQDL.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkHBPRX3WA_cjs = require('./chunk-HBPRX3WA.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/exceptions/crypto/symmetric/NotSupportCipherException.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _NotSupportCipherException = class _NotSupportCipherException extends chunkHBPRX3WA_cjs.Exception {
+  errno = "E_NOT_SUPPORT_CIPHER";
+};
+chunkGGY7LCMQ_cjs.__name(_NotSupportCipherException, "NotSupportCipherException");
+var NotSupportCipherException = _NotSupportCipherException;
+
+exports.NotSupportCipherException = NotSupportCipherException;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGNlcHRpb25zL2NyeXB0by9zeW1tZXRyaWMvTm90U3VwcG9ydENpcGhlckV4Y2VwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTtBQUVPLElBQU0sNkJBQU4sTUFBTSxtQ0FBa0MsVUFBVTtBQUFBLEVBQzlDLFFBQXlCO0FBQ3BDO0FBRnlEO0FBQWxELElBQU0sNEJBQU4iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0V4Y2VwdGlvbn0gZnJvbSAnLi4vLi4vLi4vbGliL2Jhc2UvYWJzdHJhY3RzL0V4Y2VwdGlvbi5qcydcblxuZXhwb3J0IGNsYXNzIE5vdFN1cHBvcnRDaXBoZXJFeGNlcHRpb24gZXh0ZW5kcyBFeGNlcHRpb24ge1xuICAgIHB1YmxpYyBlcnJubzogbnVtYmVyIHwgc3RyaW5nID0gJ0VfTk9UX1NVUFBPUlRfQ0lQSEVSJ1xufVxuIl19