lakutata 0.0.1

package/build/chunk-TS74DN3N.cjs

@@ -0,0 +1,229 @@
+'use strict';
+
+var chunkEFYDUUXT_cjs = require('./chunk-EFYDUUXT.cjs');
+var chunkWZI5UPER_cjs = require('./chunk-WZI5UPER.cjs');
+var chunkG7EDOLQ7_cjs = require('./chunk-G7EDOLQ7.cjs');
+var chunkEXQVCESB_cjs = require('./chunk-EXQVCESB.cjs');
+var chunkJAEEMFEZ_cjs = require('./chunk-JAEEMFEZ.cjs');
+var chunkSWCU6OID_cjs = require('./chunk-SWCU6OID.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/lib/ioc/Resolvers.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var RESOLVER = Symbol("Dependency Injection Resolver Config");
+function asValue(value) {
+  return {
+    resolve: () => value
+  };
+}
+chunkGGY7LCMQ_cjs.__name(asValue, "asValue");
+function asFunction(fn, opts) {
+  if (!chunkWZI5UPER_cjs.isFunction(fn)) {
+    throw new chunkG7EDOLQ7_cjs.DependencyInjectionTypeError("asFunction", "fn", "function", fn);
+  }
+  const defaults = {
+    lifetime: chunkJAEEMFEZ_cjs.Lifetime.TRANSIENT
+  };
+  opts = makeOptions(defaults, opts, fn[RESOLVER]);
+  const resolve = generateResolve(fn);
+  let result = {
+    resolve,
+    ...opts
+  };
+  return createDisposableResolver(createBuildResolver(result));
+}
+chunkGGY7LCMQ_cjs.__name(asFunction, "asFunction");
+function asClass(Type, opts) {
+  if (!chunkWZI5UPER_cjs.isFunction(Type)) {
+    throw new chunkG7EDOLQ7_cjs.DependencyInjectionTypeError("asClass", "Type", "class", Type);
+  }
+  const defaults = {
+    lifetime: chunkJAEEMFEZ_cjs.Lifetime.TRANSIENT
+  };
+  opts = makeOptions(defaults, opts, Type[RESOLVER]);
+  const newClass = /* @__PURE__ */ chunkGGY7LCMQ_cjs.__name(function newClass2() {
+    return Reflect.construct(Type, arguments);
+  }, "newClass");
+  const resolve = generateResolve(newClass, Type);
+  return createDisposableResolver(
+    createBuildResolver({
+      ...opts,
+      resolve
+    })
+  );
+}
+chunkGGY7LCMQ_cjs.__name(asClass, "asClass");
+function aliasTo(name) {
+  return {
+    resolve(container) {
+      return container.resolve(name);
+    }
+  };
+}
+chunkGGY7LCMQ_cjs.__name(aliasTo, "aliasTo");
+function createBuildResolver(obj) {
+  function setLifetime(value) {
+    return createBuildResolver({
+      ...this,
+      lifetime: value
+    });
+  }
+  chunkGGY7LCMQ_cjs.__name(setLifetime, "setLifetime");
+  function setInjectionMode(value) {
+    return createBuildResolver({
+      ...this,
+      injectionMode: value
+    });
+  }
+  chunkGGY7LCMQ_cjs.__name(setInjectionMode, "setInjectionMode");
+  function inject(injector) {
+    return createBuildResolver({
+      ...this,
+      injector
+    });
+  }
+  chunkGGY7LCMQ_cjs.__name(inject, "inject");
+  return updateResolver(obj, {
+    setLifetime,
+    inject,
+    transient: partial(setLifetime, chunkJAEEMFEZ_cjs.Lifetime.TRANSIENT),
+    scoped: partial(setLifetime, chunkJAEEMFEZ_cjs.Lifetime.SCOPED),
+    singleton: partial(setLifetime, chunkJAEEMFEZ_cjs.Lifetime.SINGLETON),
+    setInjectionMode,
+    proxy: partial(setInjectionMode, chunkEXQVCESB_cjs.InjectionMode.PROXY),
+    classic: partial(setInjectionMode, chunkEXQVCESB_cjs.InjectionMode.CLASSIC)
+  });
+}
+chunkGGY7LCMQ_cjs.__name(createBuildResolver, "createBuildResolver");
+function createDisposableResolver(obj) {
+  function disposer(dispose) {
+    return createDisposableResolver({
+      ...this,
+      dispose
+    });
+  }
+  chunkGGY7LCMQ_cjs.__name(disposer, "disposer");
+  return updateResolver(obj, {
+    disposer
+  });
+}
+chunkGGY7LCMQ_cjs.__name(createDisposableResolver, "createDisposableResolver");
+function partial(fn, arg1) {
+  return /* @__PURE__ */ chunkGGY7LCMQ_cjs.__name(function partiallyApplied() {
+    return fn.call(this, arg1);
+  }, "partiallyApplied");
+}
+chunkGGY7LCMQ_cjs.__name(partial, "partial");
+function makeOptions(defaults, ...rest) {
+  return Object.assign({}, defaults, ...rest);
+}
+chunkGGY7LCMQ_cjs.__name(makeOptions, "makeOptions");
+function updateResolver(source, target) {
+  const result = {
+    ...source,
+    ...target
+  };
+  return result;
+}
+chunkGGY7LCMQ_cjs.__name(updateResolver, "updateResolver");
+function wrapWithLocals(container, locals) {
+  return /* @__PURE__ */ chunkGGY7LCMQ_cjs.__name(function wrappedResolve(name, resolveOpts) {
+    if (name in locals)
+      return locals[name];
+    return container.resolve(name, resolveOpts);
+  }, "wrappedResolve");
+}
+chunkGGY7LCMQ_cjs.__name(wrapWithLocals, "wrapWithLocals");
+function createInjectorProxy(container, injector) {
+  const locals = injector(container);
+  const allKeys = chunkWZI5UPER_cjs.uniq([
+    ...Reflect.ownKeys(container.cradle),
+    ...Reflect.ownKeys(locals)
+  ]);
+  const proxy = new Proxy(
+    {},
+    {
+      /**
+       * 首先通过检查局部变量，然后再检查容器来解析值
+       */
+      get(target, name) {
+        if (name === Symbol.iterator) {
+          return /* @__PURE__ */ chunkGGY7LCMQ_cjs.__name(function* iterateRegistrationsAndLocals() {
+            for (const prop in container.cradle) {
+              yield prop;
+            }
+            for (const prop in locals) {
+              yield prop;
+            }
+          }, "iterateRegistrationsAndLocals");
+        }
+        if (name in locals) {
+          return locals[name];
+        }
+        return container.resolve(name);
+      },
+      /**
+       * Used for `Object.keys`.
+       */
+      ownKeys() {
+        return allKeys;
+      },
+      /**
+       * Used for `Object.keys`.
+       */
+      getOwnPropertyDescriptor(target, key) {
+        if (allKeys.indexOf(key) > -1) {
+          return {
+            enumerable: true,
+            configurable: true
+          };
+        }
+        return void 0;
+      }
+    }
+  );
+  return proxy;
+}
+chunkGGY7LCMQ_cjs.__name(createInjectorProxy, "createInjectorProxy");
+function generateResolve(fn, dependencyParseTarget) {
+  if (!dependencyParseTarget)
+    dependencyParseTarget = fn;
+  const dependencies = parseDependencies(dependencyParseTarget);
+  return /* @__PURE__ */ chunkGGY7LCMQ_cjs.__name(function resolve(container) {
+    const injectionMode = this.injectionMode || container.options.injectionMode || chunkEXQVCESB_cjs.InjectionMode.PROXY;
+    if (injectionMode !== chunkEXQVCESB_cjs.InjectionMode.CLASSIC) {
+      const cradle = this.injector ? createInjectorProxy(container, this.injector) : container.cradle;
+      Reflect.defineMetadata(chunkSWCU6OID_cjs.DI_CONTAINER_INJECT_PROPERTIES, true, cradle);
+      return fn(cradle);
+    }
+    if (dependencies.length > 0) {
+      const resolve2 = this.injector ? wrapWithLocals(container, this.injector(container)) : container.resolve;
+      const children = dependencies.map((p) => resolve2(p.name, { allowUnregistered: p.optional }));
+      return fn(...children);
+    }
+    return fn();
+  }, "resolve");
+}
+chunkGGY7LCMQ_cjs.__name(generateResolve, "generateResolve");
+function parseDependencies(fn) {
+  const result = chunkEFYDUUXT_cjs.parseParameterList(fn.toString());
+  if (!result) {
+    const parent = Object.getPrototypeOf(fn);
+    if (typeof parent === "function" && parent !== Function.prototype) {
+      return parseDependencies(parent);
+    }
+    return [];
+  }
+  return result;
+}
+chunkGGY7LCMQ_cjs.__name(parseDependencies, "parseDependencies");
+
+exports.RESOLVER = RESOLVER;
+exports.aliasTo = aliasTo;
+exports.asClass = asClass;
+exports.asFunction = asFunction;
+exports.asValue = asValue;
+exports.createBuildResolver = createBuildResolver;
+exports.createDisposableResolver = createDisposableResolver;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/ioc/Resolvers.ts"],"names":["newClass","resolve"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAYO,IAAM,WAAW,OAAO,sCAAsC;AA+G9D,SAAS,QAAW,OAAuB;AAC9C,SAAO;AAAA,IACH,SAAS,MAAM;AAAA,EACnB;AACJ;AAJgB;AAWT,SAAS,WACZ,IACA,MACwC;AACxC,MAAI,CAAC,WAAW,EAAE,GAAG;AACjB,UAAM,IAAI,6BAA6B,cAAc,MAAM,YAAY,EAAE;AAAA,EAC7E;AACA,QAAM,WAAW;AAAA,IACb,UAAU,SAAS;AAAA,EACvB;AACA,SAAO,YAAY,UAAU,MAAO,GAAW,QAAQ,CAAC;AACxD,QAAM,UAAU,gBAAgB,EAAE;AAClC,MAAI,SAAS;AAAA,IACT;AAAA,IACA,GAAG;AAAA,EACP;AACA,SAAO,yBAAyB,oBAAoB,MAAM,CAAC;AAC/D;AAjBgB;AAwBT,SAAS,QACZ,MACA,MACwC;AACxC,MAAI,CAAC,WAAW,IAAI,GAAG;AACnB,UAAM,IAAI,6BAA6B,WAAW,QAAQ,SAAS,IAAI;AAAA,EAC3E;AACA,QAAM,WAAuC;AAAA,IACzC,UAAU,SAAS;AAAA,EACvB;AACA,SAAO,YAAY,UAAU,MAAO,KAAa,QAAQ,CAAC;AAE1D,QAAM,WAAW,gCAASA,YAAW;AACjC,WAAO,QAAQ,UAAU,MAAM,SAAS;AAAA,EAC5C,GAFiB;AAGjB,QAAM,UAAU,gBAAgB,UAAU,IAAI;AAC9C,SAAO;AAAA,IACH,oBAAoB;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;AAtBgB;AA2BT,SAAS,QAAW,MAA2B;AAClD,SAAO;AAAA,IACH,QAAQ,WAA6C;AACjD,aAAO,UAAU,QAAQ,IAAI;AAAA,IACjC;AAAA,EACJ;AACJ;AANgB;AAYT,SAAS,oBACZ,KACoB;AACpB,WAAS,YAAuB,OAAqB;AACjD,WAAO,oBAAoB;AAAA,MACvB,GAAG;AAAA,MACH,UAAU;AAAA,IACd,CAAC;AAAA,EACL;AALS;AAOT,WAAS,iBAA4B,OAA0B;AAC3D,WAAO,oBAAoB;AAAA,MACvB,GAAG;AAAA,MACH,eAAe;AAAA,IACnB,CAAC;AAAA,EACL;AALS;AAOT,WAAS,OAAkB,UAA4B;AACnD,WAAO,oBAAoB;AAAA,MACvB,GAAG;AAAA,MACH;AAAA,IACJ,CAAC;AAAA,EACL;AALS;AAOT,SAAO,eAAe,KAAK;AAAA,IACvB;AAAA,IACA;AAAA,IACA,WAAW,QAAQ,aAAa,SAAS,SAAS;AAAA,IAClD,QAAQ,QAAQ,aAAa,SAAS,MAAM;AAAA,IAC5C,WAAW,QAAQ,aAAa,SAAS,SAAS;AAAA,IAClD;AAAA,IACA,OAAO,QAAQ,kBAAkB,cAAc,KAAK;AAAA,IACpD,SAAS,QAAQ,kBAAkB,cAAc,OAAO;AAAA,EAC5D,CAAC;AACL;AAlCgB;AAwCT,SAAS,yBACZ,KACyB;AACzB,WAAS,SAAoB,SAAsB;AAC/C,WAAO,yBAAyB;AAAA,MAC5B,GAAG;AAAA,MACH;AAAA,IACJ,CAAC;AAAA,EACL;AALS;AAOT,SAAO,eAAe,KAAK;AAAA,IACvB;AAAA,EACJ,CAAC;AACL;AAbgB;AAkBhB,SAAS,QAAe,IAAqB,MAAmB;AAC5D,SAAO,gCAAS,mBAA+B;AAC3C,WAAO,GAAG,KAAK,MAAM,IAAI;AAAA,EAC7B,GAFO;AAGX;AAJS;AAWT,SAAS,YAAkB,aAAgB,MAAmC;AAC1E,SAAO,OAAO,OAAO,CAAC,GAAG,UAAU,GAAG,IAAI;AAC9C;AAFS;AAST,SAAS,eACL,QACA,QACmB;AACnB,QAAM,SAAS;AAAA,IACX,GAAI;AAAA,IACJ,GAAI;AAAA,EACR;AACA,SAAO;AACX;AATS;AAgBT,SAAS,eACL,WACA,QACF;AACE,SAAO,gCAAS,eAAe,MAAc,aAA6B;AACtE,QAAI,QAAQ;AAAQ,aAAO,OAAO,IAAI;AACtC,WAAO,UAAU,QAAQ,MAAM,WAAW;AAAA,EAC9C,GAHO;AAIX;AARS;AAeT,SAAS,oBACL,WACA,UACF;AACE,QAAM,SAAS,SAAS,SAAS;AACjC,QAAM,UAAU,KAAK;AAAA,IACjB,GAAG,QAAQ,QAAQ,UAAU,MAAM;AAAA,IACnC,GAAG,QAAQ,QAAQ,MAAM;AAAA,EAC7B,CAAC;AAGD,QAAM,QAAQ,IAAI;AAAA,IACd,CAAC;AAAA,IACD;AAAA;AAAA;AAAA;AAAA,MAII,IAAI,QAAa,MAAuB;AACpC,YAAI,SAAS,OAAO,UAAU;AAC1B,iBAAO,iCAAU,gCAAgC;AAC7C,uBAAW,QAAQ,UAAU,QAAQ;AACjC,oBAAM;AAAA,YACV;AACA,uBAAW,QAAQ,QAAQ;AACvB,oBAAM;AAAA,YACV;AAAA,UACJ,GAPO;AAAA,QAQX;AACA,YAAI,QAAQ,QAAQ;AAChB,iBAAO,OAAO,IAAI;AAAA,QACtB;AACA,eAAO,UAAU,QAAQ,IAAc;AAAA,MAC3C;AAAA;AAAA;AAAA;AAAA,MAIA,UAAU;AACN,eAAO;AAAA,MACX;AAAA;AAAA;AAAA;AAAA,MAIA,yBAAyB,QAAa,KAAa;AAC/C,YAAI,QAAQ,QAAQ,GAAG,IAAI,IAAI;AAC3B,iBAAO;AAAA,YACH,YAAY;AAAA,YACZ,cAAc;AAAA,UAClB;AAAA,QACJ;AACA,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACJ;AACA,SAAO;AACX;AAtDS;AA6DT,SAAS,gBAAgB,IAAc,uBAAkC;AAErE,MAAI,CAAC;AAAuB,4BAAwB;AAKpD,QAAM,eAA4B,kBAAkB,qBAAqB;AAEzE,SAAO,gCAAS,QAEZ,WACF;AAGE,UAAM,gBACF,KAAK,iBACL,UAAU,QAAQ,iBAClB,cAAc;AAClB,QAAI,kBAAkB,cAAc,SAAS;AAEzC,YAAM,SAAS,KAAK,WACd,oBAAoB,WAAW,KAAK,QAAQ,IAC5C,UAAU;AAEhB,cAAQ,eAAe,gCAAgC,MAAM,MAAM;AAEnE,aAAO,GAAG,MAAM;AAAA,IACpB;AAEA,QAAI,aAAa,SAAS,GAAG;AACzB,YAAMC,WAAU,KAAK,WACf,eAAe,WAAW,KAAK,SAAS,SAAS,CAAC,IAClD,UAAU;AAChB,YAAM,WAAkB,aAAa,IAAI,CAAC,MAAiBA,SAAQ,EAAE,MAAM,EAAC,mBAAmB,EAAE,SAAQ,CAAC,CAAC;AAC3G,aAAO,GAAG,GAAG,QAAQ;AAAA,IACzB;AACA,WAAO,GAAG;AAAA,EACd,GA7BO;AA8BX;AAvCS;AA6CT,SAAS,kBAAkB,IAAgC;AACvD,QAAM,SAA6B,mBAAmB,GAAG,SAAS,CAAC;AACnE,MAAI,CAAC,QAAQ;AAGT,UAAM,SAAS,OAAO,eAAe,EAAE;AACvC,QAAI,OAAO,WAAW,cAAc,WAAW,SAAS,WAAW;AAE/D,aAAO,kBAAkB,MAAM;AAAA,IACnC;AACA,WAAO,CAAC;AAAA,EACZ;AACA,SAAO;AACX;AAbS","sourcesContent":["import 'reflect-metadata'\nimport {Lifetime, LifetimeType} from './Lifetime.js'\nimport {InjectionMode, InjectionModeType} from './InjectionMode.js'\nimport {isFunction, uniq} from './Utils.js'\nimport {parseParameterList, Parameter} from './ParamParser.js'\nimport {DependencyInjectionTypeError} from './Errors.js'\nimport {IDependencyInjectionContainer, FunctionReturning, ResolveOptions} from './DependencyInjectionContainer.js'\nimport {DI_CONTAINER_INJECT_PROPERTIES} from '../../constants/MetadataKey.js'\n\n/**\n * RESOLVER符号可以由通过loadModules加载的模块使用，用于配置它们的生命周期、注入模式等。\n */\nexport const RESOLVER = Symbol('Dependency Injection Resolver Config')\n\n/**\n * 在传递给容器后，预期RESOLVER返回一个对象，该对象的属性在配置的解析器的构造时可访问。\n * @type {Function}\n */\nexport type InjectorFunction = <T extends object>(\n    container: IDependencyInjectionContainer<T>\n) => object\n\n/**\n * asClass()、asFunction()或asValue()返回的解析器对象。\n */\nexport interface Resolver<T> extends ResolverOptions<T> {\n    resolve<U extends object>(container: IDependencyInjectionContainer<U>): T\n}\n\n/**\n * 由asClass()或asFunction()创建的解析器对象。\n */\nexport interface BuildResolver<T> extends Resolver<T>, BuildResolverOptions<T> {\n    injectionMode?: InjectionModeType\n    injector?: InjectorFunction\n\n    setLifetime(lifetime: LifetimeType): this\n\n    setInjectionMode(mode: InjectionModeType): this\n\n    singleton(): this\n\n    scoped(): this\n\n    transient(): this\n\n    proxy(): this\n\n    classic(): this\n\n    inject(injector: InjectorFunction): this\n}\n\n/**\n * 可供一次性解析器使用的选项。\n */\nexport interface DisposableResolverOptions<T> extends ResolverOptions<T> {\n    dispose?: Disposer<T>\n}\n\n/**\n * 一次性解析器（Disposable resolver）\n */\nexport interface DisposableResolver<T>\n    extends Resolver<T>,\n        DisposableResolverOptions<T> {\n    disposer(dispose: Disposer<T>): this\n}\n\n/**\n * 清理函数类型（Disposer function type）。\n */\nexport type Disposer<T> = (value: T) => any | Promise<any>\n\n/**\n * 在注册类（class）、函数（function）或值（value）时的选项。\n * @type RegistrationOptions\n */\nexport interface ResolverOptions<T> {\n    /**\n     * 仅用于与loadModules一起进行内联配置。\n     */\n    name?: string\n    /**\n     * 生命周期设置。\n     */\n    lifetime?: LifetimeType\n    /**\n     * 要使用的注册函数。仅用于与loadModules一起进行内联配置。\n     */\n    register?: (...args: any[]) => Resolver<T>\n}\n\n/**\n * 生成器解析器选项（Builder resolver options）。\n */\nexport interface BuildResolverOptions<T>\n    extends ResolverOptions<T>,\n        DisposableResolverOptions<T> {\n    /**\n     * 解析模式（Resolution mode）。\n     */\n    injectionMode?: InjectionModeType\n    /**\n     * 注入器函数，用于提供额外的参数（Injector function to provide additional parameters）。\n     */\n    injector?: InjectorFunction\n}\n\n/**\n * 一个类的构造函数。例如：\n *\n *    class MyClass {}\n *\n *    container.registerClass('myClass', MyClass)\n *                                       ^^^^^^^\n */\nexport type Constructor<T> = { new(...args: any[]): T }\n\n/**\n * 创建一个简单的值解析器，其中给定的值将始终被解析\n * @param value\n */\nexport function asValue<T>(value: T): Resolver<T> {\n    return {\n        resolve: () => value\n    }\n}\n\n/**\n * 创建一个工厂解析器，当请求时，将使用new调用给定的工厂函数\n * @param fn\n * @param opts\n */\nexport function asFunction<T>(\n    fn: FunctionReturning<T>,\n    opts?: BuildResolverOptions<T>\n): BuildResolver<T> & DisposableResolver<T> {\n    if (!isFunction(fn)) {\n        throw new DependencyInjectionTypeError('asFunction', 'fn', 'function', fn)\n    }\n    const defaults = {\n        lifetime: Lifetime.TRANSIENT\n    }\n    opts = makeOptions(defaults, opts, (fn as any)[RESOLVER])\n    const resolve = generateResolve(fn)\n    let result = {\n        resolve,\n        ...opts\n    }\n    return createDisposableResolver(createBuildResolver(result))\n}\n\n/**\n * 类似于工厂解析器，但适用于需要 new 的类\n * @param Type\n * @param opts\n */\nexport function asClass<T = {}>(\n    Type: Constructor<T>,\n    opts?: BuildResolverOptions<T>\n): BuildResolver<T> & DisposableResolver<T> {\n    if (!isFunction(Type)) {\n        throw new DependencyInjectionTypeError('asClass', 'Type', 'class', Type)\n    }\n    const defaults: { lifetime: LifetimeType } = {\n        lifetime: Lifetime.TRANSIENT\n    }\n    opts = makeOptions(defaults, opts, (Type as any)[RESOLVER])\n    // A function to handle object construction for us, as to make the generateResolve more reusable\n    const newClass = function newClass() {\n        return Reflect.construct(Type, arguments)\n    }\n    const resolve = generateResolve(newClass, Type)\n    return createDisposableResolver(\n        createBuildResolver({\n            ...opts,\n            resolve\n        })\n    )\n}\n\n/**\n * 解析为指定的注册。\n */\nexport function aliasTo<T>(name: string): Resolver<T> {\n    return {\n        resolve(container: IDependencyInjectionContainer): T {\n            return container.resolve(name)\n        }\n    }\n}\n\n/**\n * 给定一个选项对象，创建一个流式接口以管理它\n * @param obj\n */\nexport function createBuildResolver<T, B extends Resolver<T>>(\n    obj: B\n): BuildResolver<T> & B {\n    function setLifetime(this: any, value: LifetimeType) {\n        return createBuildResolver({\n            ...this,\n            lifetime: value\n        })\n    }\n\n    function setInjectionMode(this: any, value: InjectionModeType) {\n        return createBuildResolver({\n            ...this,\n            injectionMode: value\n        })\n    }\n\n    function inject(this: any, injector: InjectorFunction) {\n        return createBuildResolver({\n            ...this,\n            injector\n        })\n    }\n\n    return updateResolver(obj, {\n        setLifetime,\n        inject,\n        transient: partial(setLifetime, Lifetime.TRANSIENT),\n        scoped: partial(setLifetime, Lifetime.SCOPED),\n        singleton: partial(setLifetime, Lifetime.SINGLETON),\n        setInjectionMode,\n        proxy: partial(setInjectionMode, InjectionMode.PROXY),\n        classic: partial(setInjectionMode, InjectionMode.CLASSIC)\n    })\n}\n\n/**\n * 给定一个解析器，返回一个带有方法的对象，用于管理清理函数。\n * @param obj\n */\nexport function createDisposableResolver<T, B extends Resolver<T>>(\n    obj: B\n): DisposableResolver<T> & B {\n    function disposer(this: any, dispose: Disposer<T>) {\n        return createDisposableResolver({\n            ...this,\n            dispose\n        })\n    }\n\n    return updateResolver(obj, {\n        disposer\n    })\n}\n\n/**\n * 部分应用参数到给定的函数\n */\nfunction partial<T1, R>(fn: (arg1: T1) => R, arg1: T1): () => R {\n    return function partiallyApplied(this: any): R {\n        return fn.call(this, arg1)\n    }\n}\n\n/**\n * 基于默认值创建一个选项对象\n * @param defaults\n * @param rest\n */\nfunction makeOptions<T, O>(defaults: T, ...rest: Array<O | undefined>): T & O {\n    return Object.assign({}, defaults, ...rest) as T & O\n}\n\n/**\n * 创建一个新的解析器，其属性从两者中合并\n * @param source\n * @param target\n */\nfunction updateResolver<T, A extends Resolver<T>, B>(\n    source: A,\n    target: B\n): Resolver<T> & A & B {\n    const result = {\n        ...(source as any),\n        ...(target as any)\n    }\n    return result\n}\n\n/**\n * 返回一个包装的resolve函数，从注入器提供值，并推迟到container.resolve\n * @param container\n * @param locals\n */\nfunction wrapWithLocals<T extends object>(\n    container: IDependencyInjectionContainer<T>,\n    locals: any\n) {\n    return function wrappedResolve(name: string, resolveOpts: ResolveOptions) {\n        if (name in locals) return locals[name]\n        return container.resolve(name, resolveOpts)\n    }\n}\n\n/**\n * 返回一个新的代理（Proxy），在委托给实际容器之前，检查来自injector的结果是否包含值\n * @param container\n * @param injector\n */\nfunction createInjectorProxy<T extends object>(\n    container: IDependencyInjectionContainer<T>,\n    injector: InjectorFunction\n) {\n    const locals = injector(container) as any\n    const allKeys = uniq([\n        ...Reflect.ownKeys(container.cradle),\n        ...Reflect.ownKeys(locals)\n    ])\n    // TODO: Lots of duplication here from the container proxy.\n    // Need to refactor.\n    const proxy = new Proxy(\n        {},\n        {\n            /**\n             * 首先通过检查局部变量，然后再检查容器来解析值\n             */\n            get(target: any, name: string | symbol) {\n                if (name === Symbol.iterator) {\n                    return function* iterateRegistrationsAndLocals() {\n                        for (const prop in container.cradle) {\n                            yield prop\n                        }\n                        for (const prop in locals) {\n                            yield prop\n                        }\n                    }\n                }\n                if (name in locals) {\n                    return locals[name]\n                }\n                return container.resolve(name as string)\n            },\n            /**\n             * Used for `Object.keys`.\n             */\n            ownKeys() {\n                return allKeys\n            },\n            /**\n             * Used for `Object.keys`.\n             */\n            getOwnPropertyDescriptor(target: any, key: string) {\n                if (allKeys.indexOf(key) > -1) {\n                    return {\n                        enumerable: true,\n                        configurable: true\n                    }\n                }\n                return undefined\n            }\n        }\n    )\n    return proxy\n}\n\n/**\n * 返回一个用于构建依赖图的解析函数\n * @param fn\n * @param dependencyParseTarget\n */\nfunction generateResolve(fn: Function, dependencyParseTarget?: Function) {\n    // If the function used for dependency parsing is falsy, use the supplied function\n    if (!dependencyParseTarget) dependencyParseTarget = fn\n    // Parse out the dependencies\n    // NOTE: we do this regardless of whether PROXY is used or not,\n    // because if this fails, we want it to fail early (at startup) rather\n    // than at resolution time.\n    const dependencies: Parameter[] = parseDependencies(dependencyParseTarget)\n    // Use a regular function instead of an arrow function to facilitate binding to the resolver.\n    return function resolve<T extends object>(\n        this: BuildResolver<any>,\n        container: IDependencyInjectionContainer<T>\n    ) {\n        // Because the container holds a global reolutionMode we need to determine it in the proper order of precedence:\n        // resolver -> container -> default value\n        const injectionMode: InjectionModeType =\n            this.injectionMode ||\n            container.options.injectionMode ||\n            InjectionMode.PROXY\n        if (injectionMode !== InjectionMode.CLASSIC) {\n            // If we have a custom injector, we need to wrap the cradle.\n            const cradle = this.injector\n                ? createInjectorProxy(container, this.injector)\n                : container.cradle\n            //Define inject properties metadata\n            Reflect.defineMetadata(DI_CONTAINER_INJECT_PROPERTIES, true, cradle)\n            // Return the target injected with the cradle\n            return fn(cradle)\n        }\n        // We have dependencies so we need to resolve them manually\n        if (dependencies.length > 0) {\n            const resolve = this.injector\n                ? wrapWithLocals(container, this.injector(container))\n                : container.resolve\n            const children: any[] = dependencies.map((p: Parameter) => resolve(p.name, {allowUnregistered: p.optional}))\n            return fn(...children)\n        }\n        return fn()\n    }\n}\n\n/**\n * 从给定的函数中解析依赖项。\n * 如果它是一个继承自另一个类的类，并且它没有定义构造函数，则尝试解析它的父类构造函数。\n */\nfunction parseDependencies(fn: Function): Array<Parameter> {\n    const result: Parameter[] | null = parseParameterList(fn.toString())\n    if (!result) {\n        // No defined constructor for a class, check if there is a parent\n        // we can parse.\n        const parent = Object.getPrototypeOf(fn)\n        if (typeof parent === 'function' && parent !== Function.prototype) {\n            // Try to parse the parent\n            return parseDependencies(parent)\n        }\n        return []\n    }\n    return result\n}\n"]}

package/build/chunk-TXTNUC7S.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/SymmetricDecryptException.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _SymmetricDecryptException = class _SymmetricDecryptException extends chunkHBPRX3WA_cjs.Exception {
+  errno = "E_SYMMETRIC_DECRYPT";
+};
+chunkGGY7LCMQ_cjs.__name(_SymmetricDecryptException, "SymmetricDecryptException");
+var SymmetricDecryptException = _SymmetricDecryptException;
+
+exports.SymmetricDecryptException = SymmetricDecryptException;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGNlcHRpb25zL2NyeXB0by9zeW1tZXRyaWMvU3ltbWV0cmljRGVjcnlwdEV4Y2VwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTtBQUVPLElBQU0sNkJBQU4sTUFBTSxtQ0FBa0MsVUFBVTtBQUFBLEVBQzlDLFFBQXlCO0FBQ3BDO0FBRnlEO0FBQWxELElBQU0sNEJBQU4iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0V4Y2VwdGlvbn0gZnJvbSAnLi4vLi4vLi4vbGliL2Jhc2UvYWJzdHJhY3RzL0V4Y2VwdGlvbi5qcydcblxuZXhwb3J0IGNsYXNzIFN5bW1ldHJpY0RlY3J5cHRFeGNlcHRpb24gZXh0ZW5kcyBFeGNlcHRpb24ge1xuICAgIHB1YmxpYyBlcnJubzogbnVtYmVyIHwgc3RyaW5nID0gJ0VfU1lNTUVUUklDX0RFQ1JZUFQnXG59XG4iXX0=

package/build/chunk-UEGDBJEG.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+var chunkTS74DN3N_cjs = require('./chunk-TS74DN3N.cjs');
+var chunkWZI5UPER_cjs = require('./chunk-WZI5UPER.cjs');
+var chunkJAEEMFEZ_cjs = require('./chunk-JAEEMFEZ.cjs');
+var chunkHBPRX3WA_cjs = require('./chunk-HBPRX3WA.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+var url = require('url');
+
+// src/lib/ioc/LoadModules.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var nameFormatters = {
+  camelCase: (s) => chunkHBPRX3WA_cjs.camelCase(s)
+};
+function loadModules(dependencies, globPatterns, opts) {
+  opts ??= {};
+  const container = dependencies.container;
+  opts = optsWithDefaults(opts);
+  const modules = dependencies.listModules(globPatterns, opts);
+  if (opts.esModules) {
+    return loadEsModules(dependencies, container, modules, opts);
+  } else {
+    const result = modules.map((m) => {
+      const loaded = dependencies.require(m.path);
+      return parseLoadedModule(loaded, m);
+    });
+    return registerModules(result, container, modules, opts);
+  }
+}
+chunkGGY7LCMQ_cjs.__name(loadModules, "loadModules");
+async function loadEsModules(dependencies, container, modules, opts) {
+  const importPromises = [];
+  for (const m of modules) {
+    const fileUrl = url.pathToFileURL(m.path).toString();
+    importPromises.push(dependencies.require(fileUrl));
+  }
+  const imports = await Promise.all(importPromises);
+  const result = [];
+  for (let i = 0; i < modules.length; i++)
+    result.push(parseLoadedModule(imports[i], modules[i]));
+  return registerModules(result, container, modules, opts);
+}
+chunkGGY7LCMQ_cjs.__name(loadEsModules, "loadEsModules");
+function parseLoadedModule(loaded, m) {
+  const items = [];
+  if (!loaded)
+    return items;
+  if (chunkWZI5UPER_cjs.isFunction(loaded)) {
+    items.push({
+      name: m.name,
+      path: m.path,
+      value: loaded,
+      opts: m.opts
+    });
+    return items;
+  }
+  if (loaded.default && chunkWZI5UPER_cjs.isFunction(loaded.default)) {
+    items.push({
+      name: m.name,
+      path: m.path,
+      value: loaded.default,
+      opts: m.opts
+    });
+  }
+  for (const key of Object.keys(loaded)) {
+    if (key === "default") {
+      continue;
+    }
+    if (chunkWZI5UPER_cjs.isFunction(loaded[key]) && chunkTS74DN3N_cjs.RESOLVER in loaded[key]) {
+      items.push({
+        name: key,
+        path: m.path,
+        value: loaded[key],
+        opts: m.opts
+      });
+    }
+  }
+  return items;
+}
+chunkGGY7LCMQ_cjs.__name(parseLoadedModule, "parseLoadedModule");
+function registerModules(modulesToRegister, container, modules, opts) {
+  modulesToRegister.reduce((acc, cur) => acc.concat(cur), []).filter((x) => x).forEach(registerDescriptor.bind(null, container, opts));
+  return {
+    loadedModules: modules
+  };
+}
+chunkGGY7LCMQ_cjs.__name(registerModules, "registerModules");
+function optsWithDefaults(opts, container) {
+  return {
+    // Does a somewhat-deep merge on the registration options.
+    resolverOptions: {
+      lifetime: chunkJAEEMFEZ_cjs.Lifetime.TRANSIENT,
+      ...opts && opts.resolverOptions
+    },
+    ...opts
+  };
+}
+chunkGGY7LCMQ_cjs.__name(optsWithDefaults, "optsWithDefaults");
+function registerDescriptor(container, opts, moduleDescriptor) {
+  const inlineConfig = moduleDescriptor.value[chunkTS74DN3N_cjs.RESOLVER];
+  let name = inlineConfig && inlineConfig.name;
+  if (!name) {
+    name = moduleDescriptor.name;
+    let formatter = opts.formatName;
+    if (formatter) {
+      if (typeof formatter === "string")
+        formatter = nameFormatters[formatter];
+      if (formatter)
+        name = formatter(name, moduleDescriptor);
+    }
+  }
+  let moduleDescriptorOpts = moduleDescriptor.opts;
+  if (typeof moduleDescriptorOpts === "string")
+    moduleDescriptorOpts = { lifetime: moduleDescriptorOpts };
+  const regOpts = {
+    ...opts.resolverOptions,
+    ...moduleDescriptorOpts,
+    ...inlineConfig
+  };
+  const reg = regOpts.register ? regOpts.register : chunkWZI5UPER_cjs.isClass(moduleDescriptor.value) ? chunkTS74DN3N_cjs.asClass : chunkTS74DN3N_cjs.asFunction;
+  container.register(name, reg(moduleDescriptor.value, regOpts));
+}
+chunkGGY7LCMQ_cjs.__name(registerDescriptor, "registerDescriptor");
+
+exports.loadModules = loadModules;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/ioc/LoadModules.ts"],"names":[],"mappings":"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","sourcesContent":["import 'reflect-metadata'\nimport {pathToFileURL} from 'url'\nimport {ModuleDescriptor, GlobWithOptions, listModules} from './ListModules.js'\nimport {Lifetime} from './Lifetime.js'\nimport {\n    RESOLVER,\n    asClass,\n    asFunction,\n    BuildResolverOptions, BuildResolver\n} from './Resolvers.js'\nimport {IDependencyInjectionContainer} from './DependencyInjectionContainer.js'\nimport {isClass, isFunction} from './Utils.js'\nimport {camelCase} from 'camel-case'\n\n/**\n * 模块的元数据以及加载的模块本身\n * @interface LoadedModuleDescriptor\n */\nexport interface LoadedModuleDescriptor extends ModuleDescriptor {\n    value: unknown\n}\n\n/**\n * 调用loadModules()时的选项\n * @interface LoadModulesOptions\n */\nexport interface LoadModulesOptions<ESM extends boolean = false> {\n    cwd?: string\n    formatName?: NameFormatter | BuiltInNameFormatters\n    resolverOptions?: BuildResolverOptions<any>\n    esModules?: ESM\n}\n\n/**\n * 在使用loadModules()时，名称格式化的选项\n * @type BuiltInNameFormatters\n */\nexport type BuiltInNameFormatters = 'camelCase'\n\n/**\n * 接受正在加载的模块的文件名和模块描述符，并返回一个字符串，用于在容器中注册模块\n * descriptor.name与name相同\n * @type {NameFormatter}\n */\nexport type NameFormatter = (\n    name: string,\n    descriptor: LoadedModuleDescriptor\n) => string\n\n/**\n * loadModules的依赖项\n */\nexport interface LoadModulesDeps {\n    listModules: typeof listModules\n    container: IDependencyInjectionContainer\n\n    require(path: string): any | Promise<any>\n}\n\nconst nameFormatters: Record<string, NameFormatter> = {\n    camelCase: (s: string) => camelCase(s)\n}\n\n/**\n * 加载的模块列表\n */\nexport interface LoadModulesResult {\n    loadedModules: Array<ModuleDescriptor>\n}\n\nexport function loadModules<ESM extends boolean = false>(\n    dependencies: LoadModulesDeps,\n    globPatterns: string | Array<string | GlobWithOptions>,\n    opts?: LoadModulesOptions<ESM>\n): ESM extends true ? Promise<LoadModulesResult> : LoadModulesResult\n/**\n * 给定一个 glob 字符串数组，将在它们上调用 require，并将容器作为第一个参数调用其默认导出的函数\n *\n * @param  {IDependencyInjectionContainer} dependencies.container\n * 要安装加载的模块的容器\n *\n * @param  {Function} dependencies.listModules\n * 用于列出模块的listModules函数\n *\n * @param  {Function} dependencies.require\n * require函数 - 这是一个依赖项，因为它使得测试更加容易\n *\n * @param  {String[]} globPatterns\n * 加载模块时要使用的 glob 数组\n *\n * @param  {Object} opts\n * 传递给listModules的选项，例如{ cwd: '...' }\n *\n * @param  {(string, ModuleDescriptor) => string} opts.formatName\n * 用于格式化模块在容器中注册的名称\n *\n * @param  {boolean} opts.esModules\n * 将其设置为true以使用Node的原生ECMAScript模块\n *\n * @return {Object}\n * 返回描述结果的对象\n */\nexport function loadModules<ESM extends boolean>(\n    dependencies: LoadModulesDeps,\n    globPatterns: string | Array<string | GlobWithOptions>,\n    opts?: LoadModulesOptions<ESM>\n): Promise<LoadModulesResult> | LoadModulesResult {\n    opts ??= {}\n    const container: IDependencyInjectionContainer = dependencies.container\n    opts = optsWithDefaults(opts, container)\n    const modules: ModuleDescriptor[] = dependencies.listModules(globPatterns, opts)\n    if (opts.esModules) {\n        return loadEsModules(dependencies, container, modules, opts)\n    } else {\n        const result: LoadedModuleDescriptor[][] = modules.map((m: ModuleDescriptor) => {\n            const loaded = dependencies.require(m.path)\n            return parseLoadedModule(loaded, m)\n        })\n        return registerModules(result, container, modules, opts)\n    }\n}\n\n/**\n * 使用原生的ES6模块和异步的import()加载模块\n * @param {IDependencyInjectionContainer} container\n * @param {ModuleDescriptor[]} modules\n * @param {LoadModulesOptions} opts\n */\nasync function loadEsModules<ESM extends boolean>(\n    dependencies: LoadModulesDeps,\n    container: IDependencyInjectionContainer,\n    modules: ModuleDescriptor[],\n    opts: LoadModulesOptions<ESM>\n): Promise<LoadModulesResult> {\n    const importPromises: any[] = []\n    for (const m of modules) {\n        const fileUrl = pathToFileURL(m.path).toString()\n        importPromises.push(dependencies.require(fileUrl))\n    }\n    const imports: any[] = await Promise.all(importPromises)\n    const result: any[] = []\n    for (let i = 0; i < modules.length; i++) result.push(parseLoadedModule(imports[i], modules[i]))\n    return registerModules(result, container, modules, opts)\n}\n\n/**\n * 解析已经被引入的模块\n * @param {any} loaded\n * @param {ModuleDescriptor} m\n */\nfunction parseLoadedModule(\n    loaded: any,\n    m: ModuleDescriptor\n): Array<LoadedModuleDescriptor> {\n    const items: Array<LoadedModuleDescriptor> = []\n    if (!loaded) return items\n    if (isFunction(loaded)) {\n        items.push({\n            name: m.name,\n            path: m.path,\n            value: loaded,\n            opts: m.opts\n        })\n        return items\n    }\n    if (loaded.default && isFunction(loaded.default)) {\n        // ES6 default export\n        items.push({\n            name: m.name,\n            path: m.path,\n            value: loaded.default,\n            opts: m.opts\n        })\n    }\n    // loop through non-default exports, but require the RESOLVER property set for\n    // it to be a valid service module export.\n    for (const key of Object.keys(loaded)) {\n        if (key === 'default') {\n            // default case handled separately due to its different name (file name)\n            continue\n        }\n        if (isFunction(loaded[key]) && RESOLVER in loaded[key]) {\n            items.push({\n                name: key,\n                path: m.path,\n                value: loaded[key],\n                opts: m.opts\n            })\n        }\n    }\n    return items\n}\n\n/**\n * 注册模块\n * @param {ModuleDescriptorVal[][]} modulesToRegister\n * @param {IDependencyInjectionContainer} container\n * @param {ModuleDescriptor[]} modules\n * @param {LoadModulesOptions} opts\n */\nfunction registerModules<ESM extends boolean>(\n    modulesToRegister: LoadedModuleDescriptor[][],\n    container: IDependencyInjectionContainer,\n    modules: ModuleDescriptor[],\n    opts: LoadModulesOptions<ESM>\n): LoadModulesResult {\n    modulesToRegister\n        .reduce((acc, cur) => acc.concat(cur), [])\n        .filter((x) => x)\n        .forEach(registerDescriptor.bind(null, container, opts))\n    return {\n        loadedModules: modules\n    }\n}\n\n/**\n * 返回一个具有应用默认值的新选项对象\n */\nfunction optsWithDefaults<ESM extends boolean = false>(\n    opts: Partial<LoadModulesOptions<ESM>> | undefined,\n    container: IDependencyInjectionContainer\n): LoadModulesOptions<ESM> {\n    return {\n        // Does a somewhat-deep merge on the registration options.\n        resolverOptions: {\n            lifetime: Lifetime.TRANSIENT,\n            ...(opts && opts.resolverOptions)\n        },\n        ...opts\n    }\n}\n\n/**\n * 给定一个模块描述符，读取它并将其值注册到容器中\n * @param {IDependencyInjectionContainer} container\n * @param {LoadModulesOptions} opts\n * @param {ModuleDescriptor} moduleDescriptor\n */\nfunction registerDescriptor<ESM extends boolean = false>(\n    container: IDependencyInjectionContainer,\n    opts: LoadModulesOptions<ESM>,\n    moduleDescriptor: LoadedModuleDescriptor & { value: any }\n): void {\n    const inlineConfig = moduleDescriptor.value[RESOLVER]\n    let name = inlineConfig && inlineConfig.name\n    if (!name) {\n        name = moduleDescriptor.name\n        let formatter = opts.formatName\n        if (formatter) {\n            if (typeof formatter === 'string') formatter = nameFormatters[formatter]\n            if (formatter) name = formatter(name, moduleDescriptor)\n        }\n    }\n    let moduleDescriptorOpts = moduleDescriptor.opts\n    if (typeof moduleDescriptorOpts === 'string') moduleDescriptorOpts = {lifetime: moduleDescriptorOpts}\n    const regOpts: BuildResolver<any> = {\n        ...opts.resolverOptions,\n        ...moduleDescriptorOpts,\n        ...inlineConfig\n    }\n    const reg: Function = regOpts.register\n        ? regOpts.register\n        : isClass(moduleDescriptor.value)\n            ? asClass\n            : asFunction\n    container.register(name, reg(moduleDescriptor.value, regOpts))\n}\n"]}

package/build/chunk-UR2ZK7MI.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/InvalidAsymmetricEncryptKeyPairException.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _InvalidAsymmetricEncryptKeyPairException = class _InvalidAsymmetricEncryptKeyPairException extends chunkHBPRX3WA_cjs.Exception {
+  errno = "E_INVALID_ASYMMETRIC_ENCRYPT_KEY_PAIR";
+};
+chunkGGY7LCMQ_cjs.__name(_InvalidAsymmetricEncryptKeyPairException, "InvalidAsymmetricEncryptKeyPairException");
+var InvalidAsymmetricEncryptKeyPairException = _InvalidAsymmetricEncryptKeyPairException;
+
+exports.InvalidAsymmetricEncryptKeyPairException = InvalidAsymmetricEncryptKeyPairException;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGNlcHRpb25zL2NyeXB0by9hc3ltbWV0cmljL0ludmFsaWRBc3ltbWV0cmljRW5jcnlwdEtleVBhaXJFeGNlcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUE7QUFFTyxJQUFNLDRDQUFOLE1BQU0sa0RBQWlELFVBQVU7QUFBQSxFQUM3RCxRQUF5QjtBQUNwQztBQUZ3RTtBQUFqRSxJQUFNLDJDQUFOIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFeGNlcHRpb259IGZyb20gJy4uLy4uLy4uL2xpYi9iYXNlL2Fic3RyYWN0cy9FeGNlcHRpb24uanMnXG5cbmV4cG9ydCBjbGFzcyBJbnZhbGlkQXN5bW1ldHJpY0VuY3J5cHRLZXlQYWlyRXhjZXB0aW9uIGV4dGVuZHMgRXhjZXB0aW9uIHtcbiAgICBwdWJsaWMgZXJybm86IG51bWJlciB8IHN0cmluZyA9ICdFX0lOVkFMSURfQVNZTU1FVFJJQ19FTkNSWVBUX0tFWV9QQUlSJ1xufVxuIl19

package/build/chunk-VAOR6JOP.js

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

package/build/chunk-VELZ3KJY.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var chunkW3TQER3B_cjs = require('./chunk-W3TQER3B.cjs');
+var chunkKNSBLLL2_cjs = require('./chunk-KNSBLLL2.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/tests/modules/TestModule1/config/testConfig.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var options = {
+  entries: {
+    tt11: { class: chunkKNSBLLL2_cjs.TestComponent, greet: "subModule" }
+    // stc: {class: SubTestComponent}
+  },
+  bootstrap: [
+    async () => {
+      console.log("TestModule1 bootstrap");
+    },
+    "tt11"
+    // 'stc'
+  ]
+};
+var objectConfig = options;
+async function functionConfig() {
+  const options2 = {
+    entries: {
+      tt11: { greet: "subModule1111111" },
+      // stc: {class: (await import('../../../components/SubTestComponent.js')).SubTestComponent}
+      stc: { class: chunkW3TQER3B_cjs.SubTestComponent }
+    },
+    bootstrap: [
+      async () => {
+        console.log("TestModule1 bootstrap");
+      },
+      "tt11",
+      "stc"
+    ]
+  };
+  return options2;
+}
+chunkGGY7LCMQ_cjs.__name(functionConfig, "functionConfig");
+
+exports.functionConfig = functionConfig;
+exports.objectConfig = objectConfig;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-VHTAHAD6.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var chunkZG3PHRVQ_cjs = require('./chunk-ZG3PHRVQ.cjs');
+var chunkDN5TSX6S_cjs = require('./chunk-DN5TSX6S.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/lib/crypto/des/DES.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var import_browserify_cipher = chunkGGY7LCMQ_cjs.__toESM(chunkZG3PHRVQ_cjs.require_browserify_cipher(), 1);
+var _DES = class _DES extends chunkDN5TSX6S_cjs.SymmetricEncryption {
+  ivLength = 8;
+  keyLength = 16;
+  constructor(key, iv) {
+    super();
+    if (!arguments.length)
+      return;
+    const allowNullIV = iv === void 0;
+    const algorithm = `des-ede-${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)
+    };
+  }
+};
+chunkGGY7LCMQ_cjs.__name(_DES, "DES");
+var DES = _DES;
+
+exports.DES = DES;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-VISA22LF.js

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

package/build/chunk-VOFRWVGM.js

@@ -0,0 +1,23 @@
+import { SymmetricEncryption } from './chunk-LJTCXKC4.js';
+import { init_esm_shims, __name } from './chunk-5NK7E2HA.js';
+
+// src/lib/crypto/aria/ARIA192.ts
+init_esm_shims();
+var _ARIA192 = class _ARIA192 extends SymmetricEncryption {
+  ivLength = 16;
+  keyLength = 24;
+  constructor(key, iv) {
+    super();
+    if (!arguments.length)
+      return;
+    const allowNullIV = iv === void 0;
+    const algorithm = `aria-192-${allowNullIV ? "ecb" : "cbc"}`;
+    this.initCipher(algorithm, allowNullIV, key, iv);
+  }
+};
+__name(_ARIA192, "ARIA192");
+var ARIA192 = _ARIA192;
+
+export { ARIA192 };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9saWIvY3J5cHRvL2FyaWEvQVJJQTE5Mi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTtBQUdPLElBQU0sV0FBTixNQUFNLGlCQUFnQixvQkFBb0I7QUFBQSxFQUUxQixXQUFtQjtBQUFBLEVBRW5CLFlBQW9CO0FBQUEsRUFJdkMsWUFBWSxLQUFzQixJQUFzQjtBQUNwRCxVQUFNO0FBQ04sUUFBSSxDQUFDLFVBQVU7QUFBUTtBQUN2QixVQUFNLGNBQXVCLE9BQU87QUFDcEMsVUFBTSxZQUFvQixZQUFZLGNBQWMsUUFBUSxLQUFLO0FBQ2pFLFNBQUssV0FBVyxXQUFXLGFBQWEsS0FBSyxFQUFFO0FBQUEsRUFDbkQ7QUFDSjtBQWZpRDtBQUExQyxJQUFNLFVBQU4iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgJ3JlZmxlY3QtbWV0YWRhdGEnXG5pbXBvcnQge1N5bW1ldHJpY0VuY3J5cHRpb259IGZyb20gJy4uLy4uL2Jhc2UvYWJzdHJhY3RzL1N5bW1ldHJpY0VuY3J5cHRpb24uanMnXG5cbmV4cG9ydCBjbGFzcyBBUklBMTkyIGV4dGVuZHMgU3ltbWV0cmljRW5jcnlwdGlvbiB7XG5cbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgaXZMZW5ndGg6IG51bWJlciA9IDE2XG5cbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkga2V5TGVuZ3RoOiBudW1iZXIgPSAyNFxuXG4gICAgY29uc3RydWN0b3Ioa2V5OiBCdWZmZXIsIGl2PzogQnVmZmVyKVxuICAgIGNvbnN0cnVjdG9yKGtleTogc3RyaW5nLCBpdj86IHN0cmluZylcbiAgICBjb25zdHJ1Y3RvcihrZXk6IEJ1ZmZlciB8IHN0cmluZywgaXY/OiBCdWZmZXIgfCBzdHJpbmcpIHtcbiAgICAgICAgc3VwZXIoKVxuICAgICAgICBpZiAoIWFyZ3VtZW50cy5sZW5ndGgpIHJldHVyblxuICAgICAgICBjb25zdCBhbGxvd051bGxJVjogYm9vbGVhbiA9IGl2ID09PSB1bmRlZmluZWRcbiAgICAgICAgY29uc3QgYWxnb3JpdGhtOiBzdHJpbmcgPSBgYXJpYS0xOTItJHthbGxvd051bGxJViA/ICdlY2InIDogJ2NiYyd9YFxuICAgICAgICB0aGlzLmluaXRDaXBoZXIoYWxnb3JpdGhtLCBhbGxvd051bGxJViwga2V5LCBpdilcbiAgICB9XG59XG4iXX0=