lakutata 0.0.1

package/build/chunk-HJAQ6WJM.cjs

@@ -0,0 +1,288 @@
+'use strict';
+
+var chunkWYJCE3KY_cjs = require('./chunk-WYJCE3KY.cjs');
+var chunk4MQXSUTL_cjs = require('./chunk-4MQXSUTL.cjs');
+var chunkUEGDBJEG_cjs = require('./chunk-UEGDBJEG.cjs');
+var chunkTS74DN3N_cjs = require('./chunk-TS74DN3N.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');
+var util = require('util');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var util__namespace = /*#__PURE__*/_interopNamespace(util);
+
+// src/lib/ioc/DependencyInjectionContainer.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var FAMILY_TREE = Symbol("familyTree");
+var ROLL_UP_REGISTRATIONS = Symbol("rollUpRegistrations");
+var CRADLE_STRING_TAG = "DependencyInjectionContainerCradle";
+function createContainer(options, parentContainer) {
+  options = {
+    injectionMode: chunkEXQVCESB_cjs.InjectionMode.PROXY,
+    ...options
+  };
+  let resolutionStack = [];
+  const registrations = {};
+  const cradle = new Proxy(
+    {
+      [util__namespace.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__namespace.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 = chunkWZI5UPER_cjs.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 = chunkWZI5UPER_cjs.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 chunkG7EDOLQ7_cjs.DependencyInjectionResolutionError(
+          name,
+          resolutionStack,
+          "Cyclic dependencies detected."
+        );
+      }
+      if (name === "toJSON")
+        return toStringRepresentationFn;
+      if (name === "constructor")
+        return createContainer;
+      if (!resolver) {
+        switch (name) {
+          case util__namespace.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 chunkG7EDOLQ7_cjs.DependencyInjectionResolutionError(name, resolutionStack);
+      }
+      resolutionStack.push(name);
+      let cached;
+      let resolved;
+      switch (resolver.lifetime || chunkJAEEMFEZ_cjs.Lifetime.TRANSIENT) {
+        case chunkJAEEMFEZ_cjs.Lifetime.TRANSIENT:
+          resolved = resolver.resolve(container);
+          break;
+        case chunkJAEEMFEZ_cjs.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 chunkJAEEMFEZ_cjs.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 chunkG7EDOLQ7_cjs.DependencyInjectionResolutionError(
+            name,
+            resolutionStack,
+            `Unknown lifetime "${resolver.lifetime}"`
+          );
+      }
+      resolutionStack.pop();
+      if ((typeof resolved === "object" || typeof resolved === "function") && !Reflect.hasOwnMetadata(chunkSWCU6OID_cjs.DI_TARGET_CONSTRUCTOR_CONFIGURABLE_OBJECT_NAME, resolved))
+        Reflect.defineMetadata(chunkSWCU6OID_cjs.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";
+    chunkG7EDOLQ7_cjs.DependencyInjectionTypeError.assert(
+      targetOrResolver,
+      funcName,
+      paramName,
+      "a registration, function or class",
+      targetOrResolver
+    );
+    chunkG7EDOLQ7_cjs.DependencyInjectionTypeError.assert(
+      typeof targetOrResolver === "function",
+      funcName,
+      paramName,
+      "a function or class",
+      targetOrResolver
+    );
+    const resolver = chunkWZI5UPER_cjs.isClass(targetOrResolver) ? chunkTS74DN3N_cjs.asClass(targetOrResolver, opts) : chunkTS74DN3N_cjs.asFunction(targetOrResolver, opts);
+    return resolver.resolve(container);
+  }
+  function loadModules2(globPatterns, opts) {
+    const _loadModulesDeps = {
+      require: options.require || function(uri) {
+        return chunkGGY7LCMQ_cjs.__require(uri);
+      },
+      listModules: chunkWYJCE3KY_cjs.listModules,
+      container
+    };
+    if (opts == null ? void 0 : opts.esModules) {
+      _loadModulesDeps.require = chunk4MQXSUTL_cjs.importModule;
+      return chunkUEGDBJEG_cjs.loadModules(
+        _loadModulesDeps,
+        globPatterns,
+        opts
+      ).then(() => container);
+    } else {
+      chunkUEGDBJEG_cjs.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);
+  }
+}
+chunkGGY7LCMQ_cjs.__name(createContainer, "createContainer");
+Reflect.defineMetadata(chunkSWCU6OID_cjs.DI_CONTAINER_CREATOR_CONSTRUCTOR, true, createContainer);
+
+exports.createContainer = 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-HJSJA5CF.js

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

package/build/chunk-HKAY7FWM.js

@@ -0,0 +1,28 @@
+import { Action } from './chunk-2RW3VMNS.js';
+import { Controller } from './chunk-7MJAWOWL.js';
+import { init_esm_shims, __name, __decorateClass } from './chunk-5NK7E2HA.js';
+
+// src/tests/controllers/Test2Controller.ts
+init_esm_shims();
+var _Test2Controller = class _Test2Controller extends Controller {
+  async testHello() {
+    return `oh! this is test hello from ${this.className}`;
+  }
+  async beforeAction(subject, actionName) {
+    console.log(actionName, subject);
+    return true;
+  }
+  async afterAction(subject, actionName, actionResult) {
+    console.log(subject, actionName, actionResult);
+    return super.afterAction(subject, actionName, actionResult);
+  }
+};
+__name(_Test2Controller, "Test2Controller");
+__decorateClass([
+  Action({ test2: true })
+], _Test2Controller.prototype, "testHello", 1);
+var Test2Controller = _Test2Controller;
+
+export { Test2Controller };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90ZXN0cy9jb250cm9sbGVycy9UZXN0MkNvbnRyb2xsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7OztBQUFBO0FBR08sSUFBTSxtQkFBTixNQUFNLHlCQUF3QixXQUFXO0FBQUEsRUFHNUMsTUFBYSxZQUFZO0FBQ3JCLFdBQU8sK0JBQStCLEtBQUssU0FBUztBQUFBLEVBQ3hEO0FBQUEsRUFFQSxNQUFNLGFBQWEsU0FBOEIsWUFBd0Q7QUFDckcsWUFBUSxJQUFJLFlBQVksT0FBTztBQUMvQixXQUFPO0FBQUEsRUFDWDtBQUFBLEVBRUEsTUFBTSxZQUFZLFNBQThCLFlBQXNDLGNBQWlDO0FBQ25ILFlBQVEsSUFBSSxTQUFTLFlBQVksWUFBWTtBQUM3QyxXQUFPLE1BQU0sWUFBWSxTQUFTLFlBQVksWUFBWTtBQUFBLEVBQzlEO0FBQ0o7QUFoQmdEO0FBRy9CO0FBQUEsRUFEWixPQUFPLEVBQUMsT0FBTyxLQUFJLENBQUM7QUFBQSxHQUZaLGlCQUdJO0FBSFYsSUFBTSxrQkFBTiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q29udHJvbGxlcn0gZnJvbSAnLi4vLi4vbGliL2Jhc2UvQ29udHJvbGxlci5qcydcbmltcG9ydCB7QWN0aW9ufSBmcm9tICcuLi8uLi9kZWNvcmF0b3JzL0NvbnRyb2xsZXJEZWNvcmF0b3JzLmpzJ1xuXG5leHBvcnQgY2xhc3MgVGVzdDJDb250cm9sbGVyIGV4dGVuZHMgQ29udHJvbGxlciB7XG5cbiAgICBAQWN0aW9uKHt0ZXN0MjogdHJ1ZX0pXG4gICAgcHVibGljIGFzeW5jIHRlc3RIZWxsbygpIHtcbiAgICAgICAgcmV0dXJuIGBvaCEgdGhpcyBpcyB0ZXN0IGhlbGxvIGZyb20gJHt0aGlzLmNsYXNzTmFtZX1gXG4gICAgfVxuXG4gICAgYXN5bmMgYmVmb3JlQWN0aW9uKHN1YmplY3Q6IFJlY29yZDxzdHJpbmcsIGFueT4sIGFjdGlvbk5hbWU6IHN0cmluZyB8IHN5bWJvbCB8IG51bWJlcik6IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgICAgICBjb25zb2xlLmxvZyhhY3Rpb25OYW1lLCBzdWJqZWN0KVxuICAgICAgICByZXR1cm4gdHJ1ZVxuICAgIH1cblxuICAgIGFzeW5jIGFmdGVyQWN0aW9uKHN1YmplY3Q6IFJlY29yZDxzdHJpbmcsIGFueT4sIGFjdGlvbk5hbWU6IHN0cmluZyB8IHN5bWJvbCB8IG51bWJlciwgYWN0aW9uUmVzdWx0OiBhbnkpOiBQcm9taXNlPGFueT4ge1xuICAgICAgICBjb25zb2xlLmxvZyhzdWJqZWN0LCBhY3Rpb25OYW1lLCBhY3Rpb25SZXN1bHQpXG4gICAgICAgIHJldHVybiBzdXBlci5hZnRlckFjdGlvbihzdWJqZWN0LCBhY3Rpb25OYW1lLCBhY3Rpb25SZXN1bHQpXG4gICAgfVxufVxuIl19

package/build/chunk-HMKTNRQF.js

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