lakutata 0.0.1

package/build/chunk-LJTCXKC4.js

@@ -0,0 +1,242 @@
+import { InvalidSymmetricCipherKeyLengthException } from './chunk-MVWB4XDJ.js';
+import { NotSupportCipherException } from './chunk-QNJ6XBYQ.js';
+import { SymmetricDecryptException } from './chunk-WZZF2IEV.js';
+import { SymmetricEncryptException } from './chunk-QCA5YGYV.js';
+import { InvalidSymmetricCipherIVLengthException } from './chunk-WSEZ7DZV.js';
+import { ConvertToStream } from './chunk-XO6M5AYN.js';
+import { init_esm_shims, __name } from './chunk-5NK7E2HA.js';
+import { getCiphers, randomBytes, getCipherInfo, createCipheriv, createDecipheriv } from 'crypto';
+
+// src/lib/base/abstracts/SymmetricEncryption.ts
+init_esm_shims();
+var SUPPORT_CIPHERS = 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 : randomBytes(this.keyLength);
+    this.iv = bytesIV ? bytesIV : 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 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 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 = getCipherInfo(this.algorithm)) == null ? void 0 : _a.blockSize;
+    blockSize = blockSize ? blockSize : this.blockSize;
+    return {
+      blockSize,
+      cipherCreator: () => createCipheriv(this.algorithm, this.key, this.allowNullIV ? null : this.iv),
+      decipherCreator: () => createDecipheriv(this.algorithm, this.key, this.allowNullIV ? null : this.iv)
+    };
+  }
+  /**
+   * 当算法在运行环境原生不支持时的初始化函数
+   * @protected
+   */
+  algorithmNotFoundInitializer() {
+    throw new 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 SymmetricEncryptException(e);
+    }
+  }
+  /**
+   * 异步加密消息
+   * @param message
+   */
+  async encryptAsync(message) {
+    try {
+      return await new Promise((resolve, reject) => {
+        let cache = Buffer.from([]);
+        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 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 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 = "";
+        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 SymmetricDecryptException(e);
+    }
+  }
+  /**
+   * 获取秘钥，Hex字符串格式
+   */
+  getKey() {
+    return this.key.toString("hex");
+  }
+  /**
+   * 获取向量，Hex字符串格式
+   */
+  getIV() {
+    return this.allowNullIV ? null : this.iv.toString("hex");
+  }
+  /**
+   * 生成随机秘钥，Hex字符串格式
+   */
+  static generateKey() {
+    return randomBytes(new this().keyLength).toString("hex");
+  }
+  /**
+   * 生成随机向量，Hex字符串格式
+   */
+  static generateIV() {
+    return randomBytes(new this().ivLength).toString("hex");
+  }
+};
+__name(_SymmetricEncryption, "SymmetricEncryption");
+var SymmetricEncryption = _SymmetricEncryption;
+
+export { 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-MBKTJ3KM.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+var chunkHXWC4YN6_cjs = require('./chunk-HXWC4YN6.cjs');
+var chunk2DN35UQB_cjs = require('./chunk-2DN35UQB.cjs');
+var chunkMNDBRDT2_cjs = require('./chunk-MNDBRDT2.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+var timers = require('timers');
+
+// src/lib/base/abstracts/Interval.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _Interval = class _Interval extends chunkHXWC4YN6_cjs.BaseObject {
+  /**
+   * 周期调用器
+   * @protected
+   */
+  _$interval;
+  /**
+   * 执行器运行指示器
+   * @protected
+   */
+  _$executing = 0;
+  /**
+   * 是否被暂停
+   * @protected
+   */
+  _$paused = false;
+  mode = "SEQ";
+  interval = 1;
+  /**
+   * 定义任务
+   * @protected
+   */
+  defineJob() {
+    this._$interval = setInterval(async () => {
+      if (!chunkMNDBRDT2_cjs.IsObjectInitialized(this) || this._$paused)
+        return;
+      await this.runExecutor();
+    }, this.interval);
+  }
+  /**
+   * 重载任务
+   * @protected
+   */
+  reloadJob() {
+    if (this._$interval)
+      timers.clearInterval(this._$interval);
+    this.defineJob();
+  }
+  /**
+   * 运行执行器
+   * @protected
+   */
+  async runExecutor() {
+    if (this.mode === "SEQ" && !!this._$executing)
+      return;
+    this._$executing += 1;
+    await this.executor();
+    this._$executing -= 1;
+  }
+  /**
+   * 暂停周期调用器执行
+   */
+  pause() {
+    this._$paused = true;
+    if (this._$interval)
+      timers.clearInterval(this._$interval);
+    this._$interval = null;
+    return this;
+  }
+  /**
+   * 调用器是否已暂停执行
+   */
+  isPaused() {
+    return this._$paused;
+  }
+  /**
+   * 恢复周期调用器执行
+   */
+  resume() {
+    this._$paused = false;
+    this.reloadJob();
+    return this;
+  }
+  /**
+   * 调用器是否正在执行中
+   */
+  isExecuting() {
+    return !!this._$executing;
+  }
+  /**
+   * 销毁函数
+   * @protected
+   */
+  async destroy() {
+    if (this._$interval)
+      timers.clearInterval(this._$interval);
+    this._$interval = null;
+  }
+};
+chunkGGY7LCMQ_cjs.__name(_Interval, "Interval");
+chunkGGY7LCMQ_cjs.__decorateClass([
+  chunkHXWC4YN6_cjs.Configurable({ accept: chunk2DN35UQB_cjs.Validator.String().valid("SEQ", "TIME") })
+], _Interval.prototype, "mode", 2);
+chunkGGY7LCMQ_cjs.__decorateClass([
+  chunkHXWC4YN6_cjs.Configurable({
+    onSet: function() {
+      if (this._$paused)
+        return;
+      this.reloadJob();
+    },
+    accept: chunk2DN35UQB_cjs.Validator.Number().min(1)
+  })
+], _Interval.prototype, "interval", 2);
+var Interval = _Interval;
+
+exports.Interval = Interval;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-MDE5SRLT.cjs

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

package/build/chunk-MEKICSEL.js

@@ -0,0 +1,22 @@
+import { init_esm_shims } from './chunk-5NK7E2HA.js';
+
+// src/lib/ioc/Lifetime.ts
+init_esm_shims();
+var Lifetime = {
+  /**
+   * 注册项将会被解析一次且仅一次
+   */
+  SINGLETON: "SINGLETON",
+  /**
+   * 注册项每次都会被解析(不会缓存)
+   */
+  TRANSIENT: "TRANSIENT",
+  /**
+   * 注册项将在每个作用域中解析一次
+   */
+  SCOPED: "SCOPED"
+};
+
+export { Lifetime };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9saWIvaW9jL0xpZmV0aW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUE7QUFVTyxJQUFNLFdBQStDO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFJeEQsV0FBVztBQUFBO0FBQUE7QUFBQTtBQUFBLEVBSVgsV0FBVztBQUFBO0FBQUE7QUFBQTtBQUFBLEVBSVgsUUFBUTtBQUNaIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICdyZWZsZWN0LW1ldGFkYXRhJ1xuXG4vKipcbiAqIOeUn+WRveWRqOacn+exu+Wei1xuICovXG5leHBvcnQgdHlwZSBMaWZldGltZVR5cGUgPSAnU0lOR0xFVE9OJyB8ICdUUkFOU0lFTlQnIHwgJ1NDT1BFRCdcblxuLyoqXG4gKiDnlJ/lkb3lkajmnJ/nsbvlnotcbiAqL1xuZXhwb3J0IGNvbnN0IExpZmV0aW1lOiBSZWNvcmQ8TGlmZXRpbWVUeXBlLCBMaWZldGltZVR5cGU+ID0ge1xuICAgIC8qKlxuICAgICAqIOazqOWGjOmhueWwhuS8muiiq+ino+aekOS4gOasoeS4lOS7heS4gOasoVxuICAgICAqL1xuICAgIFNJTkdMRVRPTjogJ1NJTkdMRVRPTicsXG4gICAgLyoqXG4gICAgICog5rOo5YaM6aG55q+P5qyh6YO95Lya6KKr6Kej5p6QKOS4jeS8mue8k+WtmClcbiAgICAgKi9cbiAgICBUUkFOU0lFTlQ6ICdUUkFOU0lFTlQnLFxuICAgIC8qKlxuICAgICAqIOazqOWGjOmhueWwhuWcqOavj+S4quS9nOeUqOWfn+S4reino+aekOS4gOasoVxuICAgICAqL1xuICAgIFNDT1BFRDogJ1NDT1BFRCdcbn1cbiJdfQ==