lakutata 0.0.1

package/build/chunk-F7RNH2H2.js

@@ -0,0 +1,266 @@
+import { listModules } from './chunk-4G2ZCUBN.js';
+import { importModule } from './chunk-K2ALA7QI.js';
+import { loadModules } from './chunk-OIFILR4I.js';
+import { asClass, asFunction } from './chunk-LBL5XNWX.js';
+import { last, nameValueToObject, isClass } from './chunk-O2NOYN65.js';
+import { DependencyInjectionResolutionError, DependencyInjectionTypeError } from './chunk-YEBPQG7X.js';
+import { InjectionMode } from './chunk-EYPPC6HP.js';
+import { Lifetime } from './chunk-MEKICSEL.js';
+import { DI_CONTAINER_CREATOR_CONSTRUCTOR, DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME } from './chunk-4OHSPWRQ.js';
+import { init_esm_shims, __name, __require } from './chunk-5NK7E2HA.js';
+import * as util from 'util';
+
+// src/lib/ioc/DependencyInjectionContainer.ts
+init_esm_shims();
+var FAMILY_TREE = Symbol("familyTree");
+var ROLL_UP_REGISTRATIONS = Symbol("rollUpRegistrations");
+var CRADLE_STRING_TAG = "DependencyInjectionContainerCradle";
+function createContainer(options, parentContainer) {
+  options = {
+    injectionMode: InjectionMode.PROXY,
+    ...options
+  };
+  let resolutionStack = [];
+  const registrations = {};
+  const cradle = new Proxy(
+    {
+      [util.inspect.custom]: toStringRepresentationFn
+    },
+    {
+      /**
+       * 当进行container.cradle.*的get调用时，会调用get处理程序
+       * @param _target
+       * @param name
+       */
+      get: (_target, name) => resolve(name),
+      /**
+       * 在cradle上设置内容会抛出错误
+       * @param _target
+       * @param name
+       */
+      set: (_target, name) => {
+        throw new Error(
+          `Attempted setting property "${name}" on container cradle - this is not allowed.`
+        );
+      },
+      /**
+       * Used for `Object.keys`.
+       */
+      ownKeys() {
+        return Array.from(cradle);
+      },
+      /**
+       * Used for `Object.keys`.
+       */
+      getOwnPropertyDescriptor(target, key) {
+        const regs = rollUpRegistrations();
+        if (Object.getOwnPropertyDescriptor(regs, key))
+          return {
+            enumerable: true,
+            configurable: true
+          };
+        return void 0;
+      }
+    }
+  );
+  const container = {
+    options,
+    cradle,
+    inspect: inspect2,
+    cache: /* @__PURE__ */ new Map(),
+    loadModules: loadModules2,
+    createScope,
+    register,
+    build,
+    resolve,
+    hasRegistration,
+    dispose,
+    getRegistration,
+    [util.inspect.custom]: inspect2,
+    // tslint:disable-next-line
+    [ROLL_UP_REGISTRATIONS]: rollUpRegistrations,
+    get registrations() {
+      return rollUpRegistrations();
+    }
+  };
+  const familyTree = parentContainer ? [container].concat(parentContainer[FAMILY_TREE]) : [container];
+  container[FAMILY_TREE] = familyTree;
+  const rootContainer = last(familyTree);
+  return container;
+  function inspect2() {
+    return `[DependencyInjectionContainer (${parentContainer ? "scoped, " : ""}registrations: ${Object.keys(container.registrations).length})]`;
+  }
+  function rollUpRegistrations() {
+    return {
+      ...parentContainer && parentContainer[ROLL_UP_REGISTRATIONS](),
+      ...registrations
+    };
+  }
+  function* cradleIterator() {
+    const registrations2 = rollUpRegistrations();
+    for (const registrationName in registrations2) {
+      yield registrationName;
+    }
+  }
+  function createScope() {
+    return createContainer(options, container);
+  }
+  function register(arg1, arg2) {
+    const obj = nameValueToObject(arg1, arg2);
+    const keys = [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)];
+    for (const key of keys) {
+      const value = obj[key];
+      registrations[key] = value;
+    }
+    return container;
+  }
+  function toStringRepresentationFn() {
+    return Object.prototype.toString.call(cradle);
+  }
+  function getRegistration(name) {
+    const resolver = registrations[name];
+    if (resolver)
+      return resolver;
+    if (parentContainer)
+      return parentContainer.getRegistration(name);
+    return null;
+  }
+  function resolve(name, resolveOpts) {
+    resolveOpts = resolveOpts || {};
+    try {
+      const resolver = getRegistration(name);
+      if (resolutionStack.indexOf(name) > -1) {
+        throw new DependencyInjectionResolutionError(
+          name,
+          resolutionStack,
+          "Cyclic dependencies detected."
+        );
+      }
+      if (name === "toJSON")
+        return toStringRepresentationFn;
+      if (name === "constructor")
+        return createContainer;
+      if (!resolver) {
+        switch (name) {
+          case util.inspect.custom:
+          case "inspect":
+          case "toString":
+            return toStringRepresentationFn;
+          case Symbol.toStringTag:
+            return CRADLE_STRING_TAG;
+          case "then":
+            return void 0;
+          case Symbol.iterator:
+            return cradleIterator;
+        }
+        if (resolveOpts.allowUnregistered) {
+          return void 0;
+        }
+        throw new DependencyInjectionResolutionError(name, resolutionStack);
+      }
+      resolutionStack.push(name);
+      let cached;
+      let resolved;
+      switch (resolver.lifetime || Lifetime.TRANSIENT) {
+        case Lifetime.TRANSIENT:
+          resolved = resolver.resolve(container);
+          break;
+        case Lifetime.SINGLETON:
+          cached = rootContainer.cache.get(name);
+          if (!cached) {
+            resolved = resolver.resolve(container);
+            rootContainer.cache.set(name, { resolver, value: resolved });
+          } else {
+            resolved = cached.value;
+          }
+          break;
+        case Lifetime.SCOPED:
+          cached = container.cache.get(name);
+          if (cached !== void 0) {
+            resolved = cached.value;
+            break;
+          }
+          resolved = resolver.resolve(container);
+          container.cache.set(name, { resolver, value: resolved });
+          break;
+        default:
+          throw new DependencyInjectionResolutionError(
+            name,
+            resolutionStack,
+            `Unknown lifetime "${resolver.lifetime}"`
+          );
+      }
+      resolutionStack.pop();
+      if ((typeof resolved === "object" || typeof resolved === "function") && !Reflect.hasOwnMetadata(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME, resolved))
+        Reflect.defineMetadata(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME, name, resolved);
+      return resolved;
+    } catch (err) {
+      resolutionStack = [];
+      throw err;
+    }
+  }
+  function hasRegistration(name) {
+    return !!getRegistration(name);
+  }
+  function build(targetOrResolver, opts) {
+    if (targetOrResolver && targetOrResolver.resolve)
+      return targetOrResolver.resolve(container);
+    const funcName = "build";
+    const paramName = "targetOrResolver";
+    DependencyInjectionTypeError.assert(
+      targetOrResolver,
+      funcName,
+      paramName,
+      "a registration, function or class",
+      targetOrResolver
+    );
+    DependencyInjectionTypeError.assert(
+      typeof targetOrResolver === "function",
+      funcName,
+      paramName,
+      "a function or class",
+      targetOrResolver
+    );
+    const resolver = isClass(targetOrResolver) ? asClass(targetOrResolver, opts) : asFunction(targetOrResolver, opts);
+    return resolver.resolve(container);
+  }
+  function loadModules2(globPatterns, opts) {
+    const _loadModulesDeps = {
+      require: options.require || function(uri) {
+        return __require(uri);
+      },
+      listModules,
+      container
+    };
+    if (opts == null ? void 0 : opts.esModules) {
+      _loadModulesDeps.require = importModule;
+      return loadModules(
+        _loadModulesDeps,
+        globPatterns,
+        opts
+      ).then(() => container);
+    } else {
+      loadModules(_loadModulesDeps, globPatterns, opts);
+      return container;
+    }
+  }
+  async function dispose() {
+    const entries = Array.from(container.cache.entries());
+    container.cache.clear();
+    return Promise.all(
+      entries.map(([name, entry]) => {
+        const { resolver, value } = entry;
+        const disposable = resolver;
+        if (disposable.dispose)
+          return Promise.resolve().then(() => disposable.dispose(value));
+        return Promise.resolve();
+      })
+    ).then(() => void 0);
+  }
+}
+__name(createContainer, "createContainer");
+Reflect.defineMetadata(DI_CONTAINER_CREATOR_CONSTRUCTOR, true, createContainer);
+
+export { createContainer };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/ioc/DependencyInjectionContainer.ts"],"names":["inspect","loadModules","registrations"],"mappings":"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","sourcesContent":["import 'reflect-metadata'\nimport * as util from 'util'\nimport {GlobWithOptions, listModules} from './ListModules.js'\nimport {\n    LoadModulesOptions,\n    loadModules as realLoadModules,\n    LoadModulesResult\n} from './LoadModules.js'\nimport {\n    Resolver,\n    Constructor,\n    asClass,\n    asFunction,\n    DisposableResolver,\n    BuildResolverOptions, BuildResolver\n} from './Resolvers.js'\nimport {last, nameValueToObject, isClass} from './Utils.js'\nimport {InjectionMode, InjectionModeType} from './InjectionMode.js'\nimport {Lifetime} from './Lifetime.js'\nimport {DependencyInjectionResolutionError, DependencyInjectionTypeError} from './Errors.js'\nimport {importModule} from './LoadModuleNative.js'\nimport {\n    DI_CONTAINER_CREATOR_CONSTRUCTOR,\n    DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME\n} from '../../constants/MetadataKey.js'\n\n/**\n * 从createContainer返回的容器具有一些方法和属性。\n * @interface IDependencyInjectionContainer\n */\nexport interface IDependencyInjectionContainer<Cradle extends object = any> {\n    /**\n     * 容器配置的选项。\n     */\n    options: ContainerOptions\n    /**\n     * 在使用PROXY注入模式时注入的代理对象。\n     * 可以直接使用。\n     */\n    readonly cradle: Cradle\n    /**\n     * 获取合并容器族谱的注册信息的获取器。\n     */\n    readonly registrations: RegistrationHash\n    /**\n     * 已解析模块的缓存。\n     */\n    readonly cache: Map<string | symbol, CacheEntry>\n\n    /**\n     * 以当前容器为父容器，创建一个作用域容器。\n     */\n    createScope<T extends object = {}>(): IDependencyInjectionContainer<Cradle & T>\n\n    /**\n     * Used by `util.inspect`.\n     */\n    inspect(depth: number, opts?: any): string\n\n    /**\n     * 将lib/loadModules绑定到当前容器，并提供它所依赖的实际实现。\n     * 此外，将解析使用dependsOn API的任何模块。\n     */\n    loadModules<ESM extends boolean = false>(\n        globPatterns: Array<string | GlobWithOptions>,\n        options?: LoadModulesOptions<ESM>\n    ): ESM extends false ? this : Promise<this>\n\n    /**\n     * 添加一个单独的注册，使用预先构建的解析器。\n     */\n    register<T>(name: string | symbol, registration: Resolver<T>): this\n\n    /**\n     * 将解析器与注册名称配对并进行注册。\n     */\n    register(nameAndRegistrationPair: NameAndRegistrationPair<Cradle>): this\n\n    /**\n     * 解析具有给定名称的注册\n     * @param name\n     * @param resolveOptions\n     */\n    resolve<K extends keyof Cradle>(\n        name: K,\n        resolveOptions?: ResolveOptions\n    ): Cradle[K]\n\n    /**\n     * 解析具有给定名称的注册\n     * @param name\n     * @param resolveOptions\n     */\n    resolve<T>(name: string | symbol, resolveOptions?: ResolveOptions): T\n\n    /**\n     * 检查具有给定名称的注册是否存在\n     * @param name\n     */\n    hasRegistration(name: string | symbol): boolean\n\n    /**\n     * 递归地通过名称获取注册（如果存在于当前容器或其任何父容器中）\n     * @param name\n     */\n    getRegistration<K extends keyof Cradle>(name: K): Resolver<Cradle[K]> | null\n\n    /**\n     * 如果当前容器或其任何父容器中存在具有指定名称的注册，则递归获取该注册\n     * @param name\n     */\n    getRegistration<T = unknown>(name: string | symbol): Resolver<T> | null\n\n    /**\n     * 给定一个解析器、类或函数，构建它并返回\n     * 不缓存它，这意味着如果传递了一个解析器，那么不会使用任何在生命周期中配置的设置\n     * @param targetOrResolver\n     * @param opts\n     */\n    build<T>(\n        targetOrResolver: ClassOrFunctionReturning<T> | Resolver<T>,\n        opts?: BuildResolverOptions<T>\n    ): T\n\n    /**\n     * 销毁该容器及其子容器，对所有可释放的注册进行清理并清除缓存\n     * 仅适用于具有SCOPED或SINGLETON生命周期的注册\n     */\n    dispose(): Promise<void>\n}\n\n/**\n * 可选的解析选项。\n */\nexport interface ResolveOptions {\n    /**\n     * 如果设置为true，并且resolve无法找到请求的依赖项，则返回undefined而不是抛出错误。\n     */\n    allowUnregistered?: boolean\n}\n\n/**\n * 缓存条目。\n */\nexport interface CacheEntry<T = any> {\n    /**\n     * 解析值的解析器。\n     */\n    resolver: Resolver<T>\n    /**\n     * 解析的值。\n     */\n    value: T\n}\n\n/**\n * 注册一个注册项。\n * @interface NameAndRegistrationPair\n */\nexport type NameAndRegistrationPair<T> = {\n    [U in keyof T]?: Resolver<T[U]>\n}\n\n/**\n * 返回类型为 T 的函数。\n */\nexport type FunctionReturning<T> = (...args: Array<any>) => T\n\n/**\n * 返回 T 的类或函数。\n */\nexport type ClassOrFunctionReturning<T> = FunctionReturning<T> | Constructor<T>\n\n/**\n * createContainer 函数的选项。\n */\nexport interface ContainerOptions {\n    require?: (id: string) => any\n    injectionMode?: InjectionModeType\n}\n\n/**\n * 包含注册项的散列，其中名称是键。\n */\nexport type RegistrationHash = Record<string | symbol | number, Resolver<any>>\n\n/**\n * 解析堆栈。\n */\nexport interface ResolutionStack extends Array<string | symbol> {\n}\n\n/**\n * 家族树符号。\n */\nconst FAMILY_TREE = Symbol('familyTree')\n\n/**\n * 合并注册项符号。\n */\nconst ROLL_UP_REGISTRATIONS = Symbol('rollUpRegistrations')\n\n/**\n * 调用 toString 时的字符串表示形式。\n */\nconst CRADLE_STRING_TAG: string = 'DependencyInjectionContainerCradle'\n\n/**\n * 创建一个依赖注入容器实例\n * @param options\n * @param parentContainer\n */\nexport function createContainer<T extends object = any, U extends object = any>(\n    options?: ContainerOptions,\n    parentContainer?: IDependencyInjectionContainer<U>\n): IDependencyInjectionContainer<T> {\n    options = {\n        injectionMode: InjectionMode.PROXY,\n        ...options\n    }\n\n    // 解析堆栈用于跟踪正在解析的模块\n    let resolutionStack: ResolutionStack = []\n\n    // 此容器的内部注册存储\n    const registrations: RegistrationHash = {}\n\n    /**\n     * 传递给函数的Proxy，使它们可以在不知道依赖项来自何处的情况下解析它们。我称之为“cradle（摇篮）”，因为它是注册事物在解析时产生生命的地方。\n     */\n    const cradle: T = new Proxy(\n        {\n            [util.inspect.custom]: toStringRepresentationFn\n        },\n        {\n            /**\n             * 当进行container.cradle.*的get调用时，会调用get处理程序\n             * @param _target\n             * @param name\n             */\n            get: (_target: object, name: string): any => resolve(name),\n\n            /**\n             * 在cradle上设置内容会抛出错误\n             * @param _target\n             * @param name\n             */\n            set: (_target: object, name: string): boolean => {\n                throw new Error(\n                    `Attempted setting property \"${\n                        name as any\n                    }\" on container cradle - this is not allowed.`\n                )\n            },\n\n            /**\n             * Used for `Object.keys`.\n             */\n            ownKeys() {\n                return Array.from(cradle as any)\n            },\n\n            /**\n             * Used for `Object.keys`.\n             */\n            getOwnPropertyDescriptor(target: object, key: string | symbol): PropertyDescriptor | undefined {\n                const regs: RegistrationHash = rollUpRegistrations()\n                if (Object.getOwnPropertyDescriptor(regs, key)) return {\n                    enumerable: true,\n                    configurable: true\n                }\n                return undefined\n            }\n        }\n    ) as T\n\n    // The container being exposed.\n    const container: IDependencyInjectionContainer & any = {\n        options,\n        cradle,\n        inspect,\n        cache: new Map<string | symbol, CacheEntry>(),\n        loadModules,\n        createScope,\n        register: register as any,\n        build,\n        resolve,\n        hasRegistration,\n        dispose,\n        getRegistration,\n        [util.inspect.custom]: inspect,\n        // tslint:disable-next-line\n        [ROLL_UP_REGISTRATIONS!]: rollUpRegistrations,\n        get registrations() {\n            return rollUpRegistrations()\n        }\n    }\n\n    // 跟踪家族树\n    const familyTree: Array<IDependencyInjectionContainer> = parentContainer\n            ? [container].concat((parentContainer as any)[FAMILY_TREE])\n            : [container]\n        // 保存它，以便我们可以从作用域容器中访问它\n    ;(container as any)[FAMILY_TREE] = familyTree\n\n    // 我们需要对根容器的引用，以便我们可以检索和存储单例对象\n    const rootContainer: IDependencyInjectionContainer = last(familyTree)\n\n    return container\n\n    /**\n     * 由util.inspect使用（util.inspect又被console.log使用）\n     */\n    function inspect(): string {\n        return `[DependencyInjectionContainer (${\n            parentContainer ? 'scoped, ' : ''\n        }registrations: ${Object.keys(container.registrations).length})]`\n    }\n\n    /**\n     * 从家族树中合并注册项\n     * 这可能会非常耗费资源。仅在迭代摇篮代理时使用，这并不是日常使用中应该做的事情，主要用于调试\n     */\n    function rollUpRegistrations(): RegistrationHash {\n        return {\n            ...(parentContainer && (parentContainer as any)[ROLL_UP_REGISTRATIONS]()),\n            ...registrations\n        }\n    }\n\n    /**\n     * 用于为摇篮提供迭代器。\n     */\n    function* cradleIterator(): Generator {\n        const registrations: RegistrationHash = rollUpRegistrations()\n        for (const registrationName in registrations) {\n            yield registrationName\n        }\n    }\n\n    /**\n     * 创建一个作用域容器\n     */\n    function createScope<P extends object>(): IDependencyInjectionContainer<P & T> {\n        return createContainer(options, container as IDependencyInjectionContainer<T>)\n    }\n\n    /**\n     * 为解析器添加一个注册项。\n     */\n    function register(arg1: any, arg2: any): IDependencyInjectionContainer<T> {\n        const obj: Record<string | symbol, any> = nameValueToObject(arg1, arg2)\n        const keys: (string | symbol)[] = [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)]\n        for (const key of keys) {\n            const value: Resolver<any> = obj[key as any] as Resolver<any>\n            registrations[key as any] = value\n        }\n        return container\n    }\n\n    /**\n     * 在尝试解析摇篮上的自定义检查器函数时，返回给util.inspect和Symbol.toStringTag。\n     */\n    function toStringRepresentationFn() {\n        return Object.prototype.toString.call(cradle)\n    }\n\n    /**\n     * 如果在当前容器或其任何父容器中存在具有指定名称的注册项，则递归获取该注册项\n     * @param name\n     */\n    function getRegistration(name: string | symbol) {\n        const resolver: Resolver<any> = registrations[name]\n        if (resolver) return resolver\n        if (parentContainer) return parentContainer.getRegistration(name)\n        return null\n    }\n\n    /**\n     * 使用给定名称解析注册项\n     * @param name\n     * @param resolveOpts\n     */\n    function resolve(name: string | symbol, resolveOpts?: ResolveOptions): any {\n        resolveOpts = resolveOpts || {}\n        try {\n            // Grab the registration by name.\n            const resolver: Resolver<any> | null = getRegistration(name)\n            if (resolutionStack.indexOf(name) > -1) {\n                throw new DependencyInjectionResolutionError(\n                    name,\n                    resolutionStack,\n                    'Cyclic dependencies detected.'\n                )\n            }\n            // Used in JSON.stringify.\n            if (name === 'toJSON') return toStringRepresentationFn\n            // Used in console.log.\n            if (name === 'constructor') return createContainer\n            if (!resolver) {\n                // Checks for some edge cases.\n                switch (name) {\n                    // The following checks ensure that console.log on the cradle does not\n                    // throw an error (issue #7).\n                    case util.inspect.custom:\n                    case 'inspect':\n                    case 'toString':\n                        return toStringRepresentationFn\n                    case Symbol.toStringTag:\n                        return CRADLE_STRING_TAG\n                    // Edge case: Promise unwrapping will look for a \"then\" property and attempt to call it.\n                    // Return undefined so that we won't cause a resolution error.\n                    case 'then':\n                        return undefined\n                    // When using `Array.from` or spreading the cradle, this will\n                    // return the registration names.\n                    case Symbol.iterator:\n                        return cradleIterator\n                }\n\n                if (resolveOpts.allowUnregistered) {\n                    return undefined\n                }\n                throw new DependencyInjectionResolutionError(name, resolutionStack)\n            }\n            // Pushes the currently-resolving module name onto the stack\n            resolutionStack.push(name)\n            // Do the thing\n            let cached: CacheEntry | undefined\n            let resolved: any\n            switch (resolver.lifetime || Lifetime.TRANSIENT) {\n                case Lifetime.TRANSIENT:\n                    // Transient lifetime means resolve every time.\n                    resolved = resolver.resolve(container)\n                    break\n                case Lifetime.SINGLETON:\n                    // Singleton lifetime means cache at all times, regardless of scope.\n                    cached = rootContainer.cache.get(name)\n                    if (!cached) {\n                        resolved = resolver.resolve(container)\n                        rootContainer.cache.set(name, {resolver, value: resolved})\n                    } else {\n                        resolved = cached.value\n                    }\n                    break\n                case Lifetime.SCOPED:\n                    // Scoped lifetime means that the container\n                    // that resolves the registration also caches it.\n                    // When a registration is not found, we travel up\n                    // the family tree until we find one that is cached.\n                    cached = container.cache.get(name)\n                    if (cached !== undefined) {\n                        // We found one!\n                        resolved = cached.value\n                        break\n                    }\n                    // 如果我们还没有找到一个，我们需要解析并缓存它\n                    resolved = resolver.resolve(container)\n                    container.cache.set(name, {resolver, value: resolved})\n                    break\n                default:\n                    throw new DependencyInjectionResolutionError(\n                        name,\n                        resolutionStack,\n                        `Unknown lifetime \"${resolver.lifetime}\"`\n                    )\n            }\n            // 再次从堆栈中Pop出对象，为下一次解析做好准备\n            resolutionStack.pop()\n            /**\n             * 用于加载配置对象至注入项目内\n             */\n            if ((typeof resolved === 'object' || typeof resolved === 'function') && !Reflect.hasOwnMetadata(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME, resolved))\n                Reflect.defineMetadata(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME, name, resolved)\n            return resolved\n        } catch (err) {\n            // 当遇到错误时，需要重置堆栈\n            resolutionStack = []\n            throw err\n        }\n    }\n\n    /**\n     * 检查是否存在具有给定名称的注册项\n     * @param name\n     */\n    function hasRegistration(name: string | symbol): boolean {\n        return !!getRegistration(name)\n    }\n\n    /**\n     * 给定一个注册项、类或函数，构建其并返回。不会缓存它，这意味着如果传递了注册项，则不会使用任何配置的生命周期\n     * @param targetOrResolver\n     * @param opts\n     */\n    function build<T>(\n        targetOrResolver: Resolver<T> | ClassOrFunctionReturning<T>,\n        opts?: BuildResolverOptions<T>\n    ): T {\n        if (targetOrResolver && (targetOrResolver as Resolver<T>).resolve) return (targetOrResolver as Resolver<T>).resolve(container)\n        const funcName: string = 'build'\n        const paramName: string = 'targetOrResolver'\n        DependencyInjectionTypeError.assert(\n            targetOrResolver,\n            funcName,\n            paramName,\n            'a registration, function or class',\n            targetOrResolver\n        )\n        DependencyInjectionTypeError.assert(\n            typeof targetOrResolver === 'function',\n            funcName,\n            paramName,\n            'a function or class',\n            targetOrResolver\n        )\n        const resolver: BuildResolver<T> & DisposableResolver<T> = isClass(targetOrResolver as any)\n            ? asClass(targetOrResolver as Constructor<T>, opts)\n            : asFunction(targetOrResolver as FunctionReturning<T>, opts)\n        return resolver.resolve(container)\n    }\n\n    function loadModules<ESM extends boolean = false>(\n        globPatterns: Array<string | GlobWithOptions>,\n        opts: LoadModulesOptions<ESM>\n    ): ESM extends false ? IDependencyInjectionContainer : Promise<IDependencyInjectionContainer>\n    /**\n     * 将 lib/loadModules 绑定到此容器，并提供其依赖项的真实实现。此外，任何使用 dependsOn API 的模块都将被解析\n     * @param globPatterns\n     * @param opts\n     */\n    function loadModules<ESM extends boolean = false>(\n        globPatterns: Array<string | GlobWithOptions>,\n        opts: LoadModulesOptions<ESM>\n    ): Promise<IDependencyInjectionContainer> | IDependencyInjectionContainer {\n        const _loadModulesDeps = {\n            require:\n                options!.require ||\n                function (uri: string) {\n                    return require(uri)\n                },\n            listModules,\n            container\n        }\n        if (opts?.esModules) {\n            _loadModulesDeps.require = importModule\n            return (\n                realLoadModules(\n                    _loadModulesDeps,\n                    globPatterns,\n                    opts\n                ) as Promise<LoadModulesResult>\n            ).then(() => container)\n        } else {\n            realLoadModules(_loadModulesDeps, globPatterns, opts)\n            return container\n        }\n    }\n\n    /**\n     * 销毁该容器及其子容器，对所有可释放的注册进行清理并清除缓存\n     */\n    async function dispose(): Promise<void> {\n        const entries: [(string | symbol), CacheEntry][] = Array.from(container.cache.entries())\n        container.cache.clear()\n        return Promise.all(\n            entries.map(([name, entry]): Promise<void> => {\n                const {resolver, value} = entry\n                const disposable: DisposableResolver<any> = resolver as DisposableResolver<any>\n                if (disposable.dispose) return Promise.resolve().then(() => disposable.dispose!(value))\n                return Promise.resolve()\n            })\n        ).then(() => undefined)\n    }\n}\n\nReflect.defineMetadata(DI_CONTAINER_CREATOR_CONSTRUCTOR, true, createContainer)\n"]}

package/build/chunk-FCTV4OB7.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var chunkHWCTWIVZ_cjs = require('./chunk-HWCTWIVZ.cjs');
+var chunkX4AIZSIY_cjs = require('./chunk-X4AIZSIY.cjs');
+var chunkHXWC4YN6_cjs = require('./chunk-HXWC4YN6.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/tests/controllers/Test1Controller.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _Test1Controller = class _Test1Controller extends chunkHXWC4YN6_cjs.Controller {
+  testBoolean;
+  async test(inp) {
+    return await this.test1(inp);
+  }
+  async test1(inp) {
+    console.log("this is test1 method, the inp is:", inp);
+    return this.forward(chunkHWCTWIVZ_cjs.Test2Controller, Object.assign(inp, { test2: true }));
+  }
+  async test2() {
+    return "this is a equal 1, b equal 1";
+  }
+  async init() {
+    console.log("Configurable variable in test controller1:", this.testBoolean);
+  }
+  async destroy() {
+    console.log(this.className, "destroy!!!!!!");
+  }
+  async beforeAction(subject, method) {
+    console.log("beforeAction", subject, method, this.getInternalProperty("uniqueObjectId"));
+    return true;
+  }
+};
+chunkGGY7LCMQ_cjs.__name(_Test1Controller, "Test1Controller");
+chunkGGY7LCMQ_cjs.__decorateClass([
+  chunkHXWC4YN6_cjs.Configurable()
+], _Test1Controller.prototype, "testBoolean", 2);
+chunkGGY7LCMQ_cjs.__decorateClass([
+  chunkX4AIZSIY_cjs.Action({ a: 1 })
+], _Test1Controller.prototype, "test", 1);
+chunkGGY7LCMQ_cjs.__decorateClass([
+  chunkX4AIZSIY_cjs.Action({ a: 2 })
+], _Test1Controller.prototype, "test1", 1);
+chunkGGY7LCMQ_cjs.__decorateClass([
+  chunkX4AIZSIY_cjs.Action({ a: 1, b: 1 })
+], _Test1Controller.prototype, "test2", 1);
+var Test1Controller = _Test1Controller;
+
+exports.Test1Controller = Test1Controller;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-FHEXUE67.js

@@ -0,0 +1,29 @@
+import { Interval } from './chunk-QXTBP6TW.js';
+import { Inject, Application } from './chunk-7MJAWOWL.js';
+import { init_esm_shims, __name, __decorateClass } from './chunk-5NK7E2HA.js';
+
+// src/tests/intervals/TestInterval.ts
+init_esm_shims();
+var _TestInterval = class _TestInterval extends Interval {
+  app;
+  testComponent;
+  testObject;
+  executor() {
+    console.log(this.className, "got username:", this.testObject.getUsername());
+  }
+};
+__name(_TestInterval, "TestInterval");
+__decorateClass([
+  Inject(Application)
+], _TestInterval.prototype, "app", 2);
+__decorateClass([
+  Inject()
+], _TestInterval.prototype, "testComponent", 2);
+__decorateClass([
+  Inject()
+], _TestInterval.prototype, "testObject", 2);
+var TestInterval = _TestInterval;
+
+export { TestInterval };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90ZXN0cy9pbnRlcnZhbHMvVGVzdEludGVydmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFNTyxJQUFNLGdCQUFOLE1BQU0sc0JBQXFCLFNBQVM7QUFBQSxFQUdwQjtBQUFBLEVBR0E7QUFBQSxFQUdBO0FBQUEsRUFFVCxXQUFpQztBQUN2QyxZQUFRLElBQUksS0FBSyxXQUFXLGlCQUFpQixLQUFLLFdBQVcsWUFBWSxDQUFDO0FBQUEsRUFDOUU7QUFDSjtBQWQyQztBQUdwQjtBQUFBLEVBRGxCLE9BQU8sV0FBVztBQUFBLEdBRlYsY0FHVTtBQUdBO0FBQUEsRUFEbEIsT0FBTztBQUFBLEdBTEMsY0FNVTtBQUdBO0FBQUEsRUFEbEIsT0FBTztBQUFBLEdBUkMsY0FTVTtBQVRoQixJQUFNLGVBQU4iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0FwcGxpY2F0aW9uLCBJbnRlcnZhbH0gZnJvbSAnLi4vLi4vQ29yZS5qcydcbmltcG9ydCB7VGVzdENvbXBvbmVudH0gZnJvbSAnLi4vY29tcG9uZW50cy9UZXN0Q29tcG9uZW50LmpzJ1xuaW1wb3J0IHtJbmplY3R9IGZyb20gJy4uLy4uL2RlY29yYXRvcnMvRGVwZW5kZW5jeUluamVjdGlvbkRlY29yYXRvcnMuanMnXG5pbXBvcnQge1Rlc3RPYmplY3R9IGZyb20gJy4uL29iamVjdHMvVGVzdE9iamVjdC5qcydcbmltcG9ydCB7RElfQ09OVEFJTkVSX0lOSkVDVF9JU19NT0RVTEVfR0VUVEVSfSBmcm9tICcuLi8uLi9jb25zdGFudHMvTWV0YWRhdGFLZXkuanMnXG5cbmV4cG9ydCBjbGFzcyBUZXN0SW50ZXJ2YWwgZXh0ZW5kcyBJbnRlcnZhbCB7XG5cbiAgICBASW5qZWN0KEFwcGxpY2F0aW9uKVxuICAgIHByb3RlY3RlZCByZWFkb25seSBhcHA6IEFwcGxpY2F0aW9uXG5cbiAgICBASW5qZWN0KClcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgdGVzdENvbXBvbmVudDogVGVzdENvbXBvbmVudFxuXG4gICAgQEluamVjdCgpXG4gICAgcHJvdGVjdGVkIHJlYWRvbmx5IHRlc3RPYmplY3Q6IFRlc3RPYmplY3RcblxuICAgIHByb3RlY3RlZCBleGVjdXRvcigpOiBQcm9taXNlPHZvaWQ+IHwgdm9pZCB7XG4gICAgICAgIGNvbnNvbGUubG9nKHRoaXMuY2xhc3NOYW1lLCAnZ290IHVzZXJuYW1lOicsIHRoaXMudGVzdE9iamVjdC5nZXRVc2VybmFtZSgpKVxuICAgIH1cbn1cbiJdfQ==

package/build/chunk-FJP3KNXK.js

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

package/build/chunk-FJQSLRIP.js

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

package/build/chunk-FSFWPTIC.js

@@ -0,0 +1,6 @@
+import { init_esm_shims } from './chunk-5NK7E2HA.js';
+
+// src/interfaces/ISortArrayOptions.ts
+init_esm_shims();
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbnRlcmZhY2VzL0lTb3J0QXJyYXlPcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJ0eXBlIFRPcmRlciA9ICdhc2MnIHwgJ2Rlc2MnXG50eXBlIFRDb21wdXRlZEZ1bmN0aW9uPFQ+ID0gKCgpID0+IGFueSkgfCAoKGl0ZW06IFQpID0+IGFueSlcbnR5cGUgVENvbXB1dGVkPFQ+ID0geyBbY29tcHV0ZWRLZXk6IHN0cmluZ106IFRDb21wdXRlZEZ1bmN0aW9uPFQ+IH1cblxuZXhwb3J0IGludGVyZmFjZSBJU29ydEFycmF5T3B0aW9uczxUID0gYW55PiB7XG4gICAgcmVhZG9ubHkgYnk/OiBrZXlvZiBUIHwgc3RyaW5nXG4gICAgcmVhZG9ubHkgb3JkZXI/OiBUT3JkZXJcbiAgICByZWFkb25seSBjb21wdXRlZD86IFRDb21wdXRlZDxUPlxufVxuIl19

package/build/chunk-FTKFMQHJ.cjs

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

package/build/chunk-FW26MPE4.js

@@ -0,0 +1,69 @@
+import { AsymmetricEncryption } from './chunk-BKCT2HSQ.js';
+import { As } from './chunk-XO6M5AYN.js';
+import { init_esm_shims, __name } from './chunk-5NK7E2HA.js';
+import { createPrivateKey, createPublicKey, privateDecrypt, publicEncrypt, generateKeyPair, sign, verify } from 'crypto';
+
+// src/lib/crypto/RSA.ts
+init_esm_shims();
+var _RSA = class _RSA extends AsymmetricEncryption {
+  options = {
+    signatureAlgorithm: "sha256"
+  };
+  createPrivateKey(privateKeyString) {
+    return createPrivateKey(privateKeyString);
+  }
+  createPublicKey(publicKeyString) {
+    return createPublicKey(publicKeyString);
+  }
+  decrypt(encryptedMessage) {
+    return privateDecrypt(this.privateKey, Buffer.from(encryptedMessage, "base64")).toString();
+  }
+  encrypt(message) {
+    return publicEncrypt(this.publicKey, Buffer.from(message)).toString("base64");
+  }
+  async generateKeyPair(options) {
+    return new Promise((resolve, reject) => {
+      options = options ? options : {};
+      options.modulusLength = options.modulusLength ? options.modulusLength : 1024;
+      options.publicExponent = options.publicExponent ? options.publicExponent : 65537;
+      options.publicKeyEncoding = options.publicKeyEncoding ? options.publicKeyEncoding : {};
+      options.publicKeyEncoding.type = options.publicKeyEncoding.type ? options.publicKeyEncoding.type : "pkcs1";
+      options.publicKeyEncoding.format = options.publicKeyEncoding.format ? options.publicKeyEncoding.format : "pem";
+      options.privateKeyEncoding = options.privateKeyEncoding ? options.privateKeyEncoding : {};
+      options.privateKeyEncoding.format = options.privateKeyEncoding.format ? options.privateKeyEncoding.format : "pem";
+      options.privateKeyEncoding.type = options.privateKeyEncoding.type ? options.privateKeyEncoding.type : "pkcs1";
+      return generateKeyPair("rsa", As(options), (err, publicKey, privateKey) => {
+        if (err)
+          return reject(err);
+        return resolve({
+          publicKey: typeof publicKey === "string" ? publicKey : publicKey.toString("base64"),
+          privateKey: typeof privateKey === "string" ? privateKey : privateKey.toString("base64")
+        });
+      });
+    });
+  }
+  sign(message) {
+    return sign(this.options.signatureAlgorithm, Buffer.from(message), this.privateKey).toString("base64");
+  }
+  verify(message, sign2) {
+    return verify(this.options.signatureAlgorithm, Buffer.from(message), this.publicKey, Buffer.from(sign2, "base64"));
+  }
+  static async generateKeyPair(options) {
+    return super.generateKeyPair(options);
+  }
+  static async loadKeyPair(keyPair, options) {
+    return As(super.loadKeyPair(keyPair, options));
+  }
+  static async loadPublicKey(inp, options) {
+    return super.loadPublicKey(inp, options);
+  }
+  static async loadPrivateKey(inp, options) {
+    return super.loadPrivateKey(inp, options);
+  }
+};
+__name(_RSA, "RSA");
+var RSA = _RSA;
+
+export { RSA };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/crypto/RSA.ts"],"names":["sign"],"mappings":";;;;;;;;;;;;AAAA;AAMA;AAAA,EACI;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AA6CA,IAAM,OAAN,MAAM,aAAY,qBAAqB;AAAA,EAEhC,UAAsB;AAAA,IAC5B,oBAAoB;AAAA,EACxB;AAAA,EAEU,iBAAiB,kBAAqC;AAC5D,WAAO,iBAAiB,gBAAgB;AAAA,EAC5C;AAAA,EAEU,gBAAgB,iBAAoC;AAC1D,WAAO,gBAAgB,eAAe;AAAA,EAC1C;AAAA,EAEU,QAAQ,kBAAkC;AAChD,WAAO,eAAe,KAAK,YAAY,OAAO,KAAK,kBAAkB,QAAQ,CAAC,EAAE,SAAS;AAAA,EAC7F;AAAA,EAEU,QAAQ,SAAyB;AACvC,WAAO,cAAc,KAAK,WAAW,OAAO,KAAK,OAAO,CAAC,EAAE,SAAS,QAAQ;AAAA,EAChF;AAAA,EAEA,MAAgB,gBAAgB,SAAmE;AAC/F,WAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACpC,gBAAU,UAAU,UAAU,CAAC;AAC/B,cAAQ,gBAAgB,QAAQ,gBAAgB,QAAQ,gBAAgB;AACxE,cAAQ,iBAAiB,QAAQ,iBAAiB,QAAQ,iBAAiB;AAC3E,cAAQ,oBAAoB,QAAQ,oBAAoB,QAAQ,oBAAoB,CAAC;AACrF,cAAQ,kBAAkB,OAAO,QAAQ,kBAAkB,OAAO,QAAQ,kBAAkB,OAAO;AACnG,cAAQ,kBAAkB,SAAS,QAAQ,kBAAkB,SAAS,QAAQ,kBAAkB,SAAS;AACzG,cAAQ,qBAAqB,QAAQ,qBAAqB,QAAQ,qBAAqB,CAAC;AACxF,cAAQ,mBAAmB,SAAS,QAAQ,mBAAmB,SAAS,QAAQ,mBAAmB,SAAS;AAC5G,cAAQ,mBAAmB,OAAO,QAAQ,mBAAmB,OAAO,QAAQ,mBAAmB,OAAO;AACtG,aAAO,gBAAgB,OAAO,GAAQ,OAAO,GAAG,CAAC,KAAmB,WAA4B,eAAsC;AAClI,YAAI;AAAK,iBAAO,OAAO,GAAG;AAC1B,eAAO,QAAQ;AAAA,UACX,WAAW,OAAO,cAAc,WAAW,YAAY,UAAU,SAAS,QAAQ;AAAA,UAClF,YAAY,OAAO,eAAe,WAAW,aAAa,WAAW,SAAS,QAAQ;AAAA,QAC1F,CAAC;AAAA,MACL,CAAC;AAAA,IACL,CAAC;AAAA,EACL;AAAA,EAEU,KAAK,SAAyB;AACpC,WAAO,KAAK,KAAK,QAAQ,oBAAoB,OAAO,KAAK,OAAO,GAAG,KAAK,UAAU,EAAE,SAAS,QAAQ;AAAA,EACzG;AAAA,EAEU,OAAO,SAAiBA,OAAuB;AACrD,WAAO,OAAO,KAAK,QAAQ,oBAAoB,OAAO,KAAK,OAAO,GAAG,KAAK,WAAW,OAAO,KAAKA,OAAM,QAAQ,CAAC;AAAA,EACpH;AAAA,EAEA,aAAoB,gBAAgB,SAAmE;AACnG,WAAO,MAAM,gBAAgB,OAAO;AAAA,EACxC;AAAA,EAEA,aAAoB,YAAkD,SAAsC,SAAkC;AAC1I,WAAO,GAAM,MAAM,YAAiB,SAAS,OAAO,CAAC;AAAA,EACzD;AAAA,EAEA,aAAoB,cAAc,KAAwB,SAA2D;AACjH,WAAO,MAAM,cAAc,KAAK,OAAO;AAAA,EAC3C;AAAA,EAEA,aAAoB,eAAe,KAAwB,SAA4D;AACnH,WAAO,MAAM,eAAe,KAAK,OAAO;AAAA,EAC5C;AAEJ;AAnE8C;AAAvC,IAAM,MAAN","sourcesContent":["import 'reflect-metadata'\nimport {\n    AsymmetricEncryption,\n    AsymmetricEncryptionKeyPair, AsymmetricEncryptionPrivate,\n    AsymmetricEncryptionPublic\n} from '../base/abstracts/AsymmetricEncryption.js'\nimport {\n    createPrivateKey,\n    createPublicKey,\n    generateKeyPair,\n    KeyObject,\n    privateDecrypt,\n    publicEncrypt,\n    sign,\n    verify\n} from 'crypto'\nimport {As} from '../../Utilities.js'\nimport {PathLike} from 'fs'\n\nexport interface RSAKeyPairOptions {\n    /**\n     * 密钥长度，以bit为单位\n     * @default 1024\n     */\n    modulusLength?: number\n    /**\n     * 公钥指数\n     * @default 0x10001\n     */\n    publicExponent?: number | undefined\n    publicKeyEncoding?: {\n        /**\n         * @default pkcs1\n         */\n        type?: 'pkcs1' | 'spki'\n        /**\n         * @default pem\n         */\n        format?: 'pem' | 'der'\n    }\n    privateKeyEncoding?: {\n        /**\n         * @default pem\n         */\n        format?: 'pem' | 'der'\n        /**\n         * @default pkcs1\n         */\n        type?: 'pkcs1' | 'pkcs8';\n    }\n}\n\nexport interface RSAOptions {\n    /**\n     * 签名或验签时所使用的哈希算法\n     * @default sha256\n     */\n    signatureAlgorithm?: string\n}\n\nexport class RSA extends AsymmetricEncryption {\n\n    protected options: RSAOptions = {\n        signatureAlgorithm: 'sha256'\n    }\n\n    protected createPrivateKey(privateKeyString: string): KeyObject {\n        return createPrivateKey(privateKeyString)\n    }\n\n    protected createPublicKey(publicKeyString: string): KeyObject {\n        return createPublicKey(publicKeyString)\n    }\n\n    protected decrypt(encryptedMessage: string): string {\n        return privateDecrypt(this.privateKey, Buffer.from(encryptedMessage, 'base64')).toString()\n    }\n\n    protected encrypt(message: string): string {\n        return publicEncrypt(this.publicKey, Buffer.from(message)).toString('base64')\n    }\n\n    protected async generateKeyPair(options?: RSAKeyPairOptions): Promise<AsymmetricEncryptionKeyPair> {\n        return new Promise((resolve, reject) => {\n            options = options ? options : {}\n            options.modulusLength = options.modulusLength ? options.modulusLength : 1024\n            options.publicExponent = options.publicExponent ? options.publicExponent : 0x10001\n            options.publicKeyEncoding = options.publicKeyEncoding ? options.publicKeyEncoding : {}\n            options.publicKeyEncoding.type = options.publicKeyEncoding.type ? options.publicKeyEncoding.type : 'pkcs1'\n            options.publicKeyEncoding.format = options.publicKeyEncoding.format ? options.publicKeyEncoding.format : 'pem'\n            options.privateKeyEncoding = options.privateKeyEncoding ? options.privateKeyEncoding : {}\n            options.privateKeyEncoding.format = options.privateKeyEncoding.format ? options.privateKeyEncoding.format : 'pem'\n            options.privateKeyEncoding.type = options.privateKeyEncoding.type ? options.privateKeyEncoding.type : 'pkcs1'\n            return generateKeyPair('rsa', As<any>(options), (err: Error | null, publicKey: string | Buffer, privateKey: string | Buffer): void => {\n                if (err) return reject(err)\n                return resolve({\n                    publicKey: typeof publicKey === 'string' ? publicKey : publicKey.toString('base64'),\n                    privateKey: typeof privateKey === 'string' ? privateKey : privateKey.toString('base64')\n                })\n            })\n        })\n    }\n\n    protected sign(message: string): string {\n        return sign(this.options.signatureAlgorithm, Buffer.from(message), this.privateKey).toString('base64')\n    }\n\n    protected verify(message: string, sign: string): boolean {\n        return verify(this.options.signatureAlgorithm, Buffer.from(message), this.publicKey, Buffer.from(sign, 'base64'))\n    }\n\n    public static async generateKeyPair(options?: RSAKeyPairOptions): Promise<AsymmetricEncryptionKeyPair> {\n        return super.generateKeyPair(options)\n    }\n\n    public static async loadKeyPair<T extends AsymmetricEncryption = RSA>(keyPair: AsymmetricEncryptionKeyPair, options?: RSAOptions): Promise<T> {\n        return As<T>(super.loadKeyPair<RSA>(keyPair, options))\n    }\n\n    public static async loadPublicKey(inp: PathLike | string, options?: RSAOptions): Promise<AsymmetricEncryptionPublic> {\n        return super.loadPublicKey(inp, options)\n    }\n\n    public static async loadPrivateKey(inp: string | PathLike, options?: RSAOptions): Promise<AsymmetricEncryptionPrivate> {\n        return super.loadPrivateKey(inp, options)\n    }\n\n}\n"]}