koatty_validation 1.3.6 → 1.6.0

package/dist/index.js

@@ -1,1444 +1,473 @@
 /*!
 * @Author: richen
-* @Date: 2024-11-06 10:51:17
+* @Date: 2025-10-23 01:25:03
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
 'use strict';
 
-var classValidator = require('class-validator');
 var helper = require('koatty_lib');
+require('reflect-metadata');
 var koatty_container = require('koatty_container');
+var lruCache = require('lru-cache');
+var classValidator = require('class-validator');
 
 function _interopNamespaceDefault(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 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 helper__namespace = /*#__PURE__*/_interopNamespaceDefault(helper);
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-var _Reflect = {};
-
-/*! *****************************************************************************
-Copyright (C) Microsoft. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-var hasRequired_Reflect;
+/**
+ * koatty_validation 类型定义
+ * @author richen
+ * @copyright Copyright (c) - <richenlin(at)gmail.com>
+ * @license MIT
+ */
+/**
+ * 参数类型键常量
+ */
+const PARAM_TYPE_KEY = 'PARAM_TYPE_KEY';
 
-function require_Reflect () {
-	if (hasRequired_Reflect) return _Reflect;
-	hasRequired_Reflect = 1;
-	var Reflect;
-	(function (Reflect) {
-	    // Metadata Proposal
-	    // https://rbuckton.github.io/reflect-metadata/
-	    (function (factory) {
-	        var root = typeof globalThis === "object" ? globalThis :
-	            typeof commonjsGlobal === "object" ? commonjsGlobal :
-	                typeof self === "object" ? self :
-	                    typeof this === "object" ? this :
-	                        sloppyModeThis();
-	        var exporter = makeExporter(Reflect);
-	        if (typeof root.Reflect !== "undefined") {
-	            exporter = makeExporter(root.Reflect, exporter);
-	        }
-	        factory(exporter, root);
-	        if (typeof root.Reflect === "undefined") {
-	            root.Reflect = Reflect;
-	        }
-	        function makeExporter(target, previous) {
-	            return function (key, value) {
-	                Object.defineProperty(target, key, { configurable: true, writable: true, value: value });
-	                if (previous)
-	                    previous(key, value);
-	            };
-	        }
-	        function functionThis() {
-	            try {
-	                return Function("return this;")();
-	            }
-	            catch (_) { }
-	        }
-	        function indirectEvalThis() {
-	            try {
-	                return (void 0, eval)("(function() { return this; })()");
-	            }
-	            catch (_) { }
-	        }
-	        function sloppyModeThis() {
-	            return functionThis() || indirectEvalThis();
-	        }
-	    })(function (exporter, root) {
-	        var hasOwn = Object.prototype.hasOwnProperty;
-	        // feature test for Symbol support
-	        var supportsSymbol = typeof Symbol === "function";
-	        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
-	        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
-	        var supportsCreate = typeof Object.create === "function"; // feature test for Object.create support
-	        var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support
-	        var downLevel = !supportsCreate && !supportsProto;
-	        var HashMap = {
-	            // create an object in dictionary mode (a.k.a. "slow" mode in v8)
-	            create: supportsCreate
-	                ? function () { return MakeDictionary(Object.create(null)); }
-	                : supportsProto
-	                    ? function () { return MakeDictionary({ __proto__: null }); }
-	                    : function () { return MakeDictionary({}); },
-	            has: downLevel
-	                ? function (map, key) { return hasOwn.call(map, key); }
-	                : function (map, key) { return key in map; },
-	            get: downLevel
-	                ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }
-	                : function (map, key) { return map[key]; },
-	        };
-	        // Load global or shim versions of Map, Set, and WeakMap
-	        var functionPrototype = Object.getPrototypeOf(Function);
-	        var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
-	        var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
-	        var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
-	        var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
-	        var metadataRegistry = GetOrCreateMetadataRegistry();
-	        var metadataProvider = CreateMetadataProvider(metadataRegistry);
-	        /**
-	         * Applies a set of decorators to a property of a target object.
-	         * @param decorators An array of decorators.
-	         * @param target The target object.
-	         * @param propertyKey (Optional) The property key to decorate.
-	         * @param attributes (Optional) The property descriptor for the target key.
-	         * @remarks Decorators are applied in reverse order.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     Example = Reflect.decorate(decoratorsArray, Example);
-	         *
-	         *     // property (on constructor)
-	         *     Reflect.decorate(decoratorsArray, Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     Reflect.decorate(decoratorsArray, Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     Object.defineProperty(Example, "staticMethod",
-	         *         Reflect.decorate(decoratorsArray, Example, "staticMethod",
-	         *             Object.getOwnPropertyDescriptor(Example, "staticMethod")));
-	         *
-	         *     // method (on prototype)
-	         *     Object.defineProperty(Example.prototype, "method",
-	         *         Reflect.decorate(decoratorsArray, Example.prototype, "method",
-	         *             Object.getOwnPropertyDescriptor(Example.prototype, "method")));
-	         *
-	         */
-	        function decorate(decorators, target, propertyKey, attributes) {
-	            if (!IsUndefined(propertyKey)) {
-	                if (!IsArray(decorators))
-	                    throw new TypeError();
-	                if (!IsObject(target))
-	                    throw new TypeError();
-	                if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
-	                    throw new TypeError();
-	                if (IsNull(attributes))
-	                    attributes = undefined;
-	                propertyKey = ToPropertyKey(propertyKey);
-	                return DecorateProperty(decorators, target, propertyKey, attributes);
-	            }
-	            else {
-	                if (!IsArray(decorators))
-	                    throw new TypeError();
-	                if (!IsConstructor(target))
-	                    throw new TypeError();
-	                return DecorateConstructor(decorators, target);
-	            }
-	        }
-	        exporter("decorate", decorate);
-	        // 4.1.2 Reflect.metadata(metadataKey, metadataValue)
-	        // https://rbuckton.github.io/reflect-metadata/#reflect.metadata
-	        /**
-	         * A default metadata decorator factory that can be used on a class, class member, or parameter.
-	         * @param metadataKey The key for the metadata entry.
-	         * @param metadataValue The value for the metadata entry.
-	         * @returns A decorator function.
-	         * @remarks
-	         * If `metadataKey` is already defined for the target and target key, the
-	         * metadataValue for that key will be overwritten.
-	         * @example
-	         *
-	         *     // constructor
-	         *     @Reflect.metadata(key, value)
-	         *     class Example {
-	         *     }
-	         *
-	         *     // property (on constructor, TypeScript only)
-	         *     class Example {
-	         *         @Reflect.metadata(key, value)
-	         *         static staticProperty;
-	         *     }
-	         *
-	         *     // property (on prototype, TypeScript only)
-	         *     class Example {
-	         *         @Reflect.metadata(key, value)
-	         *         property;
-	         *     }
-	         *
-	         *     // method (on constructor)
-	         *     class Example {
-	         *         @Reflect.metadata(key, value)
-	         *         static staticMethod() { }
-	         *     }
-	         *
-	         *     // method (on prototype)
-	         *     class Example {
-	         *         @Reflect.metadata(key, value)
-	         *         method() { }
-	         *     }
-	         *
-	         */
-	        function metadata(metadataKey, metadataValue) {
-	            function decorator(target, propertyKey) {
-	                if (!IsObject(target))
-	                    throw new TypeError();
-	                if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
-	                    throw new TypeError();
-	                OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-	            }
-	            return decorator;
-	        }
-	        exporter("metadata", metadata);
-	        /**
-	         * Define a unique metadata entry on the target.
-	         * @param metadataKey A key used to store and retrieve metadata.
-	         * @param metadataValue A value that contains attached metadata.
-	         * @param target The target object on which to define metadata.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     Reflect.defineMetadata("custom:annotation", options, Example);
-	         *
-	         *     // property (on constructor)
-	         *     Reflect.defineMetadata("custom:annotation", options, Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     Reflect.defineMetadata("custom:annotation", options, Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "method");
-	         *
-	         *     // decorator factory as metadata-producing annotation.
-	         *     function MyAnnotation(options): Decorator {
-	         *         return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key);
-	         *     }
-	         *
-	         */
-	        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-	        }
-	        exporter("defineMetadata", defineMetadata);
-	        /**
-	         * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-	         * @param metadataKey A key used to store and retrieve metadata.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.hasMetadata("custom:annotation", Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
-	         *
-	         */
-	        function hasMetadata(metadataKey, target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryHasMetadata(metadataKey, target, propertyKey);
-	        }
-	        exporter("hasMetadata", hasMetadata);
-	        /**
-	         * Gets a value indicating whether the target object has the provided metadata key defined.
-	         * @param metadataKey A key used to store and retrieve metadata.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.hasOwnMetadata("custom:annotation", Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
-	         *
-	         */
-	        function hasOwnMetadata(metadataKey, target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
-	        }
-	        exporter("hasOwnMetadata", hasOwnMetadata);
-	        /**
-	         * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-	         * @param metadataKey A key used to store and retrieve metadata.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.getMetadata("custom:annotation", Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
-	         *
-	         */
-	        function getMetadata(metadataKey, target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryGetMetadata(metadataKey, target, propertyKey);
-	        }
-	        exporter("getMetadata", getMetadata);
-	        /**
-	         * Gets the metadata value for the provided metadata key on the target object.
-	         * @param metadataKey A key used to store and retrieve metadata.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.getOwnMetadata("custom:annotation", Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
-	         *
-	         */
-	        function getOwnMetadata(metadataKey, target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
-	        }
-	        exporter("getOwnMetadata", getOwnMetadata);
-	        /**
-	         * Gets the metadata keys defined on the target object or its prototype chain.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns An array of unique metadata keys.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.getMetadataKeys(Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.getMetadataKeys(Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.getMetadataKeys(Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.getMetadataKeys(Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.getMetadataKeys(Example.prototype, "method");
-	         *
-	         */
-	        function getMetadataKeys(target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryMetadataKeys(target, propertyKey);
-	        }
-	        exporter("getMetadataKeys", getMetadataKeys);
-	        /**
-	         * Gets the unique metadata keys defined on the target object.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns An array of unique metadata keys.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.getOwnMetadataKeys(Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
-	         *
-	         */
-	        function getOwnMetadataKeys(target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            return OrdinaryOwnMetadataKeys(target, propertyKey);
-	        }
-	        exporter("getOwnMetadataKeys", getOwnMetadataKeys);
-	        /**
-	         * Deletes the metadata entry from the target object with the provided key.
-	         * @param metadataKey A key used to store and retrieve metadata.
-	         * @param target The target object on which the metadata is defined.
-	         * @param propertyKey (Optional) The property key for the target.
-	         * @returns `true` if the metadata entry was found and deleted; otherwise, false.
-	         * @example
-	         *
-	         *     class Example {
-	         *         // property declarations are not part of ES6, though they are valid in TypeScript:
-	         *         // static staticProperty;
-	         *         // property;
-	         *
-	         *         constructor(p) { }
-	         *         static staticMethod(p) { }
-	         *         method(p) { }
-	         *     }
-	         *
-	         *     // constructor
-	         *     result = Reflect.deleteMetadata("custom:annotation", Example);
-	         *
-	         *     // property (on constructor)
-	         *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
-	         *
-	         *     // property (on prototype)
-	         *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
-	         *
-	         *     // method (on constructor)
-	         *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
-	         *
-	         *     // method (on prototype)
-	         *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
-	         *
-	         */
-	        function deleteMetadata(metadataKey, target, propertyKey) {
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            if (!IsObject(target))
-	                throw new TypeError();
-	            if (!IsUndefined(propertyKey))
-	                propertyKey = ToPropertyKey(propertyKey);
-	            var provider = GetMetadataProvider(target, propertyKey, /*Create*/ false);
-	            if (IsUndefined(provider))
-	                return false;
-	            return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
-	        }
-	        exporter("deleteMetadata", deleteMetadata);
-	        function DecorateConstructor(decorators, target) {
-	            for (var i = decorators.length - 1; i >= 0; --i) {
-	                var decorator = decorators[i];
-	                var decorated = decorator(target);
-	                if (!IsUndefined(decorated) && !IsNull(decorated)) {
-	                    if (!IsConstructor(decorated))
-	                        throw new TypeError();
-	                    target = decorated;
-	                }
-	            }
-	            return target;
-	        }
-	        function DecorateProperty(decorators, target, propertyKey, descriptor) {
-	            for (var i = decorators.length - 1; i >= 0; --i) {
-	                var decorator = decorators[i];
-	                var decorated = decorator(target, propertyKey, descriptor);
-	                if (!IsUndefined(decorated) && !IsNull(decorated)) {
-	                    if (!IsObject(decorated))
-	                        throw new TypeError();
-	                    descriptor = decorated;
-	                }
-	            }
-	            return descriptor;
-	        }
-	        // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata
-	        function OrdinaryHasMetadata(MetadataKey, O, P) {
-	            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-	            if (hasOwn)
-	                return true;
-	            var parent = OrdinaryGetPrototypeOf(O);
-	            if (!IsNull(parent))
-	                return OrdinaryHasMetadata(MetadataKey, parent, P);
-	            return false;
-	        }
-	        // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata
-	        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
-	            var provider = GetMetadataProvider(O, P, /*Create*/ false);
-	            if (IsUndefined(provider))
-	                return false;
-	            return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
-	        }
-	        // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata
-	        function OrdinaryGetMetadata(MetadataKey, O, P) {
-	            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-	            if (hasOwn)
-	                return OrdinaryGetOwnMetadata(MetadataKey, O, P);
-	            var parent = OrdinaryGetPrototypeOf(O);
-	            if (!IsNull(parent))
-	                return OrdinaryGetMetadata(MetadataKey, parent, P);
-	            return undefined;
-	        }
-	        // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata
-	        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
-	            var provider = GetMetadataProvider(O, P, /*Create*/ false);
-	            if (IsUndefined(provider))
-	                return;
-	            return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
-	        }
-	        // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata
-	        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
-	            var provider = GetMetadataProvider(O, P, /*Create*/ true);
-	            provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
-	        }
-	        // 3.1.6.1 OrdinaryMetadataKeys(O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys
-	        function OrdinaryMetadataKeys(O, P) {
-	            var ownKeys = OrdinaryOwnMetadataKeys(O, P);
-	            var parent = OrdinaryGetPrototypeOf(O);
-	            if (parent === null)
-	                return ownKeys;
-	            var parentKeys = OrdinaryMetadataKeys(parent, P);
-	            if (parentKeys.length <= 0)
-	                return ownKeys;
-	            if (ownKeys.length <= 0)
-	                return parentKeys;
-	            var set = new _Set();
-	            var keys = [];
-	            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
-	                var key = ownKeys_1[_i];
-	                var hasKey = set.has(key);
-	                if (!hasKey) {
-	                    set.add(key);
-	                    keys.push(key);
-	                }
-	            }
-	            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
-	                var key = parentKeys_1[_a];
-	                var hasKey = set.has(key);
-	                if (!hasKey) {
-	                    set.add(key);
-	                    keys.push(key);
-	                }
-	            }
-	            return keys;
-	        }
-	        // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)
-	        // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys
-	        function OrdinaryOwnMetadataKeys(O, P) {
-	            var provider = GetMetadataProvider(O, P, /*create*/ false);
-	            if (!provider) {
-	                return [];
-	            }
-	            return provider.OrdinaryOwnMetadataKeys(O, P);
-	        }
-	        // 6 ECMAScript Data Typ0es and Values
-	        // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
-	        function Type(x) {
-	            if (x === null)
-	                return 1 /* Null */;
-	            switch (typeof x) {
-	                case "undefined": return 0 /* Undefined */;
-	                case "boolean": return 2 /* Boolean */;
-	                case "string": return 3 /* String */;
-	                case "symbol": return 4 /* Symbol */;
-	                case "number": return 5 /* Number */;
-	                case "object": return x === null ? 1 /* Null */ : 6 /* Object */;
-	                default: return 6 /* Object */;
-	            }
-	        }
-	        // 6.1.1 The Undefined Type
-	        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type
-	        function IsUndefined(x) {
-	            return x === undefined;
-	        }
-	        // 6.1.2 The Null Type
-	        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type
-	        function IsNull(x) {
-	            return x === null;
-	        }
-	        // 6.1.5 The Symbol Type
-	        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type
-	        function IsSymbol(x) {
-	            return typeof x === "symbol";
-	        }
-	        // 6.1.7 The Object Type
-	        // https://tc39.github.io/ecma262/#sec-object-type
-	        function IsObject(x) {
-	            return typeof x === "object" ? x !== null : typeof x === "function";
-	        }
-	        // 7.1 Type Conversion
-	        // https://tc39.github.io/ecma262/#sec-type-conversion
-	        // 7.1.1 ToPrimitive(input [, PreferredType])
-	        // https://tc39.github.io/ecma262/#sec-toprimitive
-	        function ToPrimitive(input, PreferredType) {
-	            switch (Type(input)) {
-	                case 0 /* Undefined */: return input;
-	                case 1 /* Null */: return input;
-	                case 2 /* Boolean */: return input;
-	                case 3 /* String */: return input;
-	                case 4 /* Symbol */: return input;
-	                case 5 /* Number */: return input;
-	            }
-	            var hint = "string" ;
-	            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
-	            if (exoticToPrim !== undefined) {
-	                var result = exoticToPrim.call(input, hint);
-	                if (IsObject(result))
-	                    throw new TypeError();
-	                return result;
-	            }
-	            return OrdinaryToPrimitive(input);
-	        }
-	        // 7.1.1.1 OrdinaryToPrimitive(O, hint)
-	        // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive
-	        function OrdinaryToPrimitive(O, hint) {
-	            var valueOf, result; {
-	                var toString_1 = O.toString;
-	                if (IsCallable(toString_1)) {
-	                    var result = toString_1.call(O);
-	                    if (!IsObject(result))
-	                        return result;
-	                }
-	                var valueOf = O.valueOf;
-	                if (IsCallable(valueOf)) {
-	                    var result = valueOf.call(O);
-	                    if (!IsObject(result))
-	                        return result;
-	                }
-	            }
-	            throw new TypeError();
-	        }
-	        // 7.1.2 ToBoolean(argument)
-	        // https://tc39.github.io/ecma262/2016/#sec-toboolean
-	        function ToBoolean(argument) {
-	            return !!argument;
-	        }
-	        // 7.1.12 ToString(argument)
-	        // https://tc39.github.io/ecma262/#sec-tostring
-	        function ToString(argument) {
-	            return "" + argument;
-	        }
-	        // 7.1.14 ToPropertyKey(argument)
-	        // https://tc39.github.io/ecma262/#sec-topropertykey
-	        function ToPropertyKey(argument) {
-	            var key = ToPrimitive(argument);
-	            if (IsSymbol(key))
-	                return key;
-	            return ToString(key);
-	        }
-	        // 7.2 Testing and Comparison Operations
-	        // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations
-	        // 7.2.2 IsArray(argument)
-	        // https://tc39.github.io/ecma262/#sec-isarray
-	        function IsArray(argument) {
-	            return Array.isArray
-	                ? Array.isArray(argument)
-	                : argument instanceof Object
-	                    ? argument instanceof Array
-	                    : Object.prototype.toString.call(argument) === "[object Array]";
-	        }
-	        // 7.2.3 IsCallable(argument)
-	        // https://tc39.github.io/ecma262/#sec-iscallable
-	        function IsCallable(argument) {
-	            // NOTE: This is an approximation as we cannot check for [[Call]] internal method.
-	            return typeof argument === "function";
-	        }
-	        // 7.2.4 IsConstructor(argument)
-	        // https://tc39.github.io/ecma262/#sec-isconstructor
-	        function IsConstructor(argument) {
-	            // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.
-	            return typeof argument === "function";
-	        }
-	        // 7.2.7 IsPropertyKey(argument)
-	        // https://tc39.github.io/ecma262/#sec-ispropertykey
-	        function IsPropertyKey(argument) {
-	            switch (Type(argument)) {
-	                case 3 /* String */: return true;
-	                case 4 /* Symbol */: return true;
-	                default: return false;
-	            }
-	        }
-	        function SameValueZero(x, y) {
-	            return x === y || x !== x && y !== y;
-	        }
-	        // 7.3 Operations on Objects
-	        // https://tc39.github.io/ecma262/#sec-operations-on-objects
-	        // 7.3.9 GetMethod(V, P)
-	        // https://tc39.github.io/ecma262/#sec-getmethod
-	        function GetMethod(V, P) {
-	            var func = V[P];
-	            if (func === undefined || func === null)
-	                return undefined;
-	            if (!IsCallable(func))
-	                throw new TypeError();
-	            return func;
-	        }
-	        // 7.4 Operations on Iterator Objects
-	        // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects
-	        function GetIterator(obj) {
-	            var method = GetMethod(obj, iteratorSymbol);
-	            if (!IsCallable(method))
-	                throw new TypeError(); // from Call
-	            var iterator = method.call(obj);
-	            if (!IsObject(iterator))
-	                throw new TypeError();
-	            return iterator;
-	        }
-	        // 7.4.4 IteratorValue(iterResult)
-	        // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue
-	        function IteratorValue(iterResult) {
-	            return iterResult.value;
-	        }
-	        // 7.4.5 IteratorStep(iterator)
-	        // https://tc39.github.io/ecma262/#sec-iteratorstep
-	        function IteratorStep(iterator) {
-	            var result = iterator.next();
-	            return result.done ? false : result;
-	        }
-	        // 7.4.6 IteratorClose(iterator, completion)
-	        // https://tc39.github.io/ecma262/#sec-iteratorclose
-	        function IteratorClose(iterator) {
-	            var f = iterator["return"];
-	            if (f)
-	                f.call(iterator);
-	        }
-	        // 9.1 Ordinary Object Internal Methods and Internal Slots
-	        // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots
-	        // 9.1.1.1 OrdinaryGetPrototypeOf(O)
-	        // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof
-	        function OrdinaryGetPrototypeOf(O) {
-	            var proto = Object.getPrototypeOf(O);
-	            if (typeof O !== "function" || O === functionPrototype)
-	                return proto;
-	            // TypeScript doesn't set __proto__ in ES5, as it's non-standard.
-	            // Try to determine the superclass constructor. Compatible implementations
-	            // must either set __proto__ on a subclass constructor to the superclass constructor,
-	            // or ensure each class has a valid `constructor` property on its prototype that
-	            // points back to the constructor.
-	            // If this is not the same as Function.[[Prototype]], then this is definately inherited.
-	            // This is the case when in ES6 or when using __proto__ in a compatible browser.
-	            if (proto !== functionPrototype)
-	                return proto;
-	            // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.
-	            var prototype = O.prototype;
-	            var prototypeProto = prototype && Object.getPrototypeOf(prototype);
-	            if (prototypeProto == null || prototypeProto === Object.prototype)
-	                return proto;
-	            // If the constructor was not a function, then we cannot determine the heritage.
-	            var constructor = prototypeProto.constructor;
-	            if (typeof constructor !== "function")
-	                return proto;
-	            // If we have some kind of self-reference, then we cannot determine the heritage.
-	            if (constructor === O)
-	                return proto;
-	            // we have a pretty good guess at the heritage.
-	            return constructor;
-	        }
-	        // Global metadata registry
-	        // - Allows `import "reflect-metadata"` and `import "reflect-metadata/no-conflict"` to interoperate.
-	        // - Uses isolated metadata if `Reflect` is frozen before the registry can be installed.
-	        /**
-	         * Creates a registry used to allow multiple `reflect-metadata` providers.
-	         */
-	        function CreateMetadataRegistry() {
-	            var fallback;
-	            if (!IsUndefined(registrySymbol) &&
-	                typeof root.Reflect !== "undefined" &&
-	                !(registrySymbol in root.Reflect) &&
-	                typeof root.Reflect.defineMetadata === "function") {
-	                // interoperate with older version of `reflect-metadata` that did not support a registry.
-	                fallback = CreateFallbackProvider(root.Reflect);
-	            }
-	            var first;
-	            var second;
-	            var rest;
-	            var targetProviderMap = new _WeakMap();
-	            var registry = {
-	                registerProvider: registerProvider,
-	                getProvider: getProvider,
-	                setProvider: setProvider,
-	            };
-	            return registry;
-	            function registerProvider(provider) {
-	                if (!Object.isExtensible(registry)) {
-	                    throw new Error("Cannot add provider to a frozen registry.");
-	                }
-	                switch (true) {
-	                    case fallback === provider: break;
-	                    case IsUndefined(first):
-	                        first = provider;
-	                        break;
-	                    case first === provider: break;
-	                    case IsUndefined(second):
-	                        second = provider;
-	                        break;
-	                    case second === provider: break;
-	                    default:
-	                        if (rest === undefined)
-	                            rest = new _Set();
-	                        rest.add(provider);
-	                        break;
-	                }
-	            }
-	            function getProviderNoCache(O, P) {
-	                if (!IsUndefined(first)) {
-	                    if (first.isProviderFor(O, P))
-	                        return first;
-	                    if (!IsUndefined(second)) {
-	                        if (second.isProviderFor(O, P))
-	                            return first;
-	                        if (!IsUndefined(rest)) {
-	                            var iterator = GetIterator(rest);
-	                            while (true) {
-	                                var next = IteratorStep(iterator);
-	                                if (!next) {
-	                                    return undefined;
-	                                }
-	                                var provider = IteratorValue(next);
-	                                if (provider.isProviderFor(O, P)) {
-	                                    IteratorClose(iterator);
-	                                    return provider;
-	                                }
-	                            }
-	                        }
-	                    }
-	                }
-	                if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
-	                    return fallback;
-	                }
-	                return undefined;
-	            }
-	            function getProvider(O, P) {
-	                var providerMap = targetProviderMap.get(O);
-	                var provider;
-	                if (!IsUndefined(providerMap)) {
-	                    provider = providerMap.get(P);
-	                }
-	                if (!IsUndefined(provider)) {
-	                    return provider;
-	                }
-	                provider = getProviderNoCache(O, P);
-	                if (!IsUndefined(provider)) {
-	                    if (IsUndefined(providerMap)) {
-	                        providerMap = new _Map();
-	                        targetProviderMap.set(O, providerMap);
-	                    }
-	                    providerMap.set(P, provider);
-	                }
-	                return provider;
-	            }
-	            function hasProvider(provider) {
-	                if (IsUndefined(provider))
-	                    throw new TypeError();
-	                return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
-	            }
-	            function setProvider(O, P, provider) {
-	                if (!hasProvider(provider)) {
-	                    throw new Error("Metadata provider not registered.");
-	                }
-	                var existingProvider = getProvider(O, P);
-	                if (existingProvider !== provider) {
-	                    if (!IsUndefined(existingProvider)) {
-	                        return false;
-	                    }
-	                    var providerMap = targetProviderMap.get(O);
-	                    if (IsUndefined(providerMap)) {
-	                        providerMap = new _Map();
-	                        targetProviderMap.set(O, providerMap);
-	                    }
-	                    providerMap.set(P, provider);
-	                }
-	                return true;
-	            }
-	        }
-	        /**
-	         * Gets or creates the shared registry of metadata providers.
-	         */
-	        function GetOrCreateMetadataRegistry() {
-	            var metadataRegistry;
-	            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
-	                metadataRegistry = root.Reflect[registrySymbol];
-	            }
-	            if (IsUndefined(metadataRegistry)) {
-	                metadataRegistry = CreateMetadataRegistry();
-	            }
-	            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
-	                Object.defineProperty(root.Reflect, registrySymbol, {
-	                    enumerable: false,
-	                    configurable: false,
-	                    writable: false,
-	                    value: metadataRegistry
-	                });
-	            }
-	            return metadataRegistry;
-	        }
-	        function CreateMetadataProvider(registry) {
-	            // [[Metadata]] internal slot
-	            // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots
-	            var metadata = new _WeakMap();
-	            var provider = {
-	                isProviderFor: function (O, P) {
-	                    var targetMetadata = metadata.get(O);
-	                    if (IsUndefined(targetMetadata))
-	                        return false;
-	                    return targetMetadata.has(P);
-	                },
-	                OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata,
-	                OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata,
-	                OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata,
-	                OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys,
-	                OrdinaryDeleteMetadata: OrdinaryDeleteMetadata,
-	            };
-	            metadataRegistry.registerProvider(provider);
-	            return provider;
-	            function GetOrCreateMetadataMap(O, P, Create) {
-	                var targetMetadata = metadata.get(O);
-	                var createdTargetMetadata = false;
-	                if (IsUndefined(targetMetadata)) {
-	                    if (!Create)
-	                        return undefined;
-	                    targetMetadata = new _Map();
-	                    metadata.set(O, targetMetadata);
-	                    createdTargetMetadata = true;
-	                }
-	                var metadataMap = targetMetadata.get(P);
-	                if (IsUndefined(metadataMap)) {
-	                    if (!Create)
-	                        return undefined;
-	                    metadataMap = new _Map();
-	                    targetMetadata.set(P, metadataMap);
-	                    if (!registry.setProvider(O, P, provider)) {
-	                        targetMetadata.delete(P);
-	                        if (createdTargetMetadata) {
-	                            metadata.delete(O);
-	                        }
-	                        throw new Error("Wrong provider for target.");
-	                    }
-	                }
-	                return metadataMap;
-	            }
-	            // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)
-	            // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata
-	            function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
-	                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
-	                if (IsUndefined(metadataMap))
-	                    return false;
-	                return ToBoolean(metadataMap.has(MetadataKey));
-	            }
-	            // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)
-	            // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata
-	            function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
-	                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
-	                if (IsUndefined(metadataMap))
-	                    return undefined;
-	                return metadataMap.get(MetadataKey);
-	            }
-	            // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)
-	            // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata
-	            function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
-	                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);
-	                metadataMap.set(MetadataKey, MetadataValue);
-	            }
-	            // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)
-	            // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys
-	            function OrdinaryOwnMetadataKeys(O, P) {
-	                var keys = [];
-	                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
-	                if (IsUndefined(metadataMap))
-	                    return keys;
-	                var keysObj = metadataMap.keys();
-	                var iterator = GetIterator(keysObj);
-	                var k = 0;
-	                while (true) {
-	                    var next = IteratorStep(iterator);
-	                    if (!next) {
-	                        keys.length = k;
-	                        return keys;
-	                    }
-	                    var nextValue = IteratorValue(next);
-	                    try {
-	                        keys[k] = nextValue;
-	                    }
-	                    catch (e) {
-	                        try {
-	                            IteratorClose(iterator);
-	                        }
-	                        finally {
-	                            throw e;
-	                        }
-	                    }
-	                    k++;
-	                }
-	            }
-	            function OrdinaryDeleteMetadata(MetadataKey, O, P) {
-	                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
-	                if (IsUndefined(metadataMap))
-	                    return false;
-	                if (!metadataMap.delete(MetadataKey))
-	                    return false;
-	                if (metadataMap.size === 0) {
-	                    var targetMetadata = metadata.get(O);
-	                    if (!IsUndefined(targetMetadata)) {
-	                        targetMetadata.delete(P);
-	                        if (targetMetadata.size === 0) {
-	                            metadata.delete(targetMetadata);
-	                        }
-	                    }
-	                }
-	                return true;
-	            }
-	        }
-	        function CreateFallbackProvider(reflect) {
-	            var defineMetadata = reflect.defineMetadata, hasOwnMetadata = reflect.hasOwnMetadata, getOwnMetadata = reflect.getOwnMetadata, getOwnMetadataKeys = reflect.getOwnMetadataKeys, deleteMetadata = reflect.deleteMetadata;
-	            var metadataOwner = new _WeakMap();
-	            var provider = {
-	                isProviderFor: function (O, P) {
-	                    var metadataPropertySet = metadataOwner.get(O);
-	                    if (!IsUndefined(metadataPropertySet)) {
-	                        return metadataPropertySet.has(P);
-	                    }
-	                    if (getOwnMetadataKeys(O, P).length) {
-	                        if (IsUndefined(metadataPropertySet)) {
-	                            metadataPropertySet = new _Set();
-	                            metadataOwner.set(O, metadataPropertySet);
-	                        }
-	                        metadataPropertySet.add(P);
-	                        return true;
-	                    }
-	                    return false;
-	                },
-	                OrdinaryDefineOwnMetadata: defineMetadata,
-	                OrdinaryHasOwnMetadata: hasOwnMetadata,
-	                OrdinaryGetOwnMetadata: getOwnMetadata,
-	                OrdinaryOwnMetadataKeys: getOwnMetadataKeys,
-	                OrdinaryDeleteMetadata: deleteMetadata,
-	            };
-	            return provider;
-	        }
-	        /**
-	         * Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,
-	         * then this module's metadata provider is assigned to the object.
-	         */
-	        function GetMetadataProvider(O, P, Create) {
-	            var registeredProvider = metadataRegistry.getProvider(O, P);
-	            if (!IsUndefined(registeredProvider)) {
-	                return registeredProvider;
-	            }
-	            if (Create) {
-	                if (metadataRegistry.setProvider(O, P, metadataProvider)) {
-	                    return metadataProvider;
-	                }
-	                throw new Error("Illegal state.");
-	            }
-	            return undefined;
-	        }
-	        // naive Map shim
-	        function CreateMapPolyfill() {
-	            var cacheSentinel = {};
-	            var arraySentinel = [];
-	            var MapIterator = /** @class */ (function () {
-	                function MapIterator(keys, values, selector) {
-	                    this._index = 0;
-	                    this._keys = keys;
-	                    this._values = values;
-	                    this._selector = selector;
-	                }
-	                MapIterator.prototype["@@iterator"] = function () { return this; };
-	                MapIterator.prototype[iteratorSymbol] = function () { return this; };
-	                MapIterator.prototype.next = function () {
-	                    var index = this._index;
-	                    if (index >= 0 && index < this._keys.length) {
-	                        var result = this._selector(this._keys[index], this._values[index]);
-	                        if (index + 1 >= this._keys.length) {
-	                            this._index = -1;
-	                            this._keys = arraySentinel;
-	                            this._values = arraySentinel;
-	                        }
-	                        else {
-	                            this._index++;
-	                        }
-	                        return { value: result, done: false };
-	                    }
-	                    return { value: undefined, done: true };
-	                };
-	                MapIterator.prototype.throw = function (error) {
-	                    if (this._index >= 0) {
-	                        this._index = -1;
-	                        this._keys = arraySentinel;
-	                        this._values = arraySentinel;
-	                    }
-	                    throw error;
-	                };
-	                MapIterator.prototype.return = function (value) {
-	                    if (this._index >= 0) {
-	                        this._index = -1;
-	                        this._keys = arraySentinel;
-	                        this._values = arraySentinel;
-	                    }
-	                    return { value: value, done: true };
-	                };
-	                return MapIterator;
-	            }());
-	            var Map = /** @class */ (function () {
-	                function Map() {
-	                    this._keys = [];
-	                    this._values = [];
-	                    this._cacheKey = cacheSentinel;
-	                    this._cacheIndex = -2;
-	                }
-	                Object.defineProperty(Map.prototype, "size", {
-	                    get: function () { return this._keys.length; },
-	                    enumerable: true,
-	                    configurable: true
-	                });
-	                Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };
-	                Map.prototype.get = function (key) {
-	                    var index = this._find(key, /*insert*/ false);
-	                    return index >= 0 ? this._values[index] : undefined;
-	                };
-	                Map.prototype.set = function (key, value) {
-	                    var index = this._find(key, /*insert*/ true);
-	                    this._values[index] = value;
-	                    return this;
-	                };
-	                Map.prototype.delete = function (key) {
-	                    var index = this._find(key, /*insert*/ false);
-	                    if (index >= 0) {
-	                        var size = this._keys.length;
-	                        for (var i = index + 1; i < size; i++) {
-	                            this._keys[i - 1] = this._keys[i];
-	                            this._values[i - 1] = this._values[i];
-	                        }
-	                        this._keys.length--;
-	                        this._values.length--;
-	                        if (SameValueZero(key, this._cacheKey)) {
-	                            this._cacheKey = cacheSentinel;
-	                            this._cacheIndex = -2;
-	                        }
-	                        return true;
-	                    }
-	                    return false;
-	                };
-	                Map.prototype.clear = function () {
-	                    this._keys.length = 0;
-	                    this._values.length = 0;
-	                    this._cacheKey = cacheSentinel;
-	                    this._cacheIndex = -2;
-	                };
-	                Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };
-	                Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };
-	                Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };
-	                Map.prototype["@@iterator"] = function () { return this.entries(); };
-	                Map.prototype[iteratorSymbol] = function () { return this.entries(); };
-	                Map.prototype._find = function (key, insert) {
-	                    if (!SameValueZero(this._cacheKey, key)) {
-	                        this._cacheIndex = -1;
-	                        for (var i = 0; i < this._keys.length; i++) {
-	                            if (SameValueZero(this._keys[i], key)) {
-	                                this._cacheIndex = i;
-	                                break;
-	                            }
-	                        }
-	                    }
-	                    if (this._cacheIndex < 0 && insert) {
-	                        this._cacheIndex = this._keys.length;
-	                        this._keys.push(key);
-	                        this._values.push(undefined);
-	                    }
-	                    return this._cacheIndex;
-	                };
-	                return Map;
-	            }());
-	            return Map;
-	            function getKey(key, _) {
-	                return key;
-	            }
-	            function getValue(_, value) {
-	                return value;
-	            }
-	            function getEntry(key, value) {
-	                return [key, value];
-	            }
-	        }
-	        // naive Set shim
-	        function CreateSetPolyfill() {
-	            var Set = /** @class */ (function () {
-	                function Set() {
-	                    this._map = new _Map();
-	                }
-	                Object.defineProperty(Set.prototype, "size", {
-	                    get: function () { return this._map.size; },
-	                    enumerable: true,
-	                    configurable: true
-	                });
-	                Set.prototype.has = function (value) { return this._map.has(value); };
-	                Set.prototype.add = function (value) { return this._map.set(value, value), this; };
-	                Set.prototype.delete = function (value) { return this._map.delete(value); };
-	                Set.prototype.clear = function () { this._map.clear(); };
-	                Set.prototype.keys = function () { return this._map.keys(); };
-	                Set.prototype.values = function () { return this._map.keys(); };
-	                Set.prototype.entries = function () { return this._map.entries(); };
-	                Set.prototype["@@iterator"] = function () { return this.keys(); };
-	                Set.prototype[iteratorSymbol] = function () { return this.keys(); };
-	                return Set;
-	            }());
-	            return Set;
-	        }
-	        // naive WeakMap shim
-	        function CreateWeakMapPolyfill() {
-	            var UUID_SIZE = 16;
-	            var keys = HashMap.create();
-	            var rootKey = CreateUniqueKey();
-	            return /** @class */ (function () {
-	                function WeakMap() {
-	                    this._key = CreateUniqueKey();
-	                }
-	                WeakMap.prototype.has = function (target) {
-	                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);
-	                    return table !== undefined ? HashMap.has(table, this._key) : false;
-	                };
-	                WeakMap.prototype.get = function (target) {
-	                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);
-	                    return table !== undefined ? HashMap.get(table, this._key) : undefined;
-	                };
-	                WeakMap.prototype.set = function (target, value) {
-	                    var table = GetOrCreateWeakMapTable(target, /*create*/ true);
-	                    table[this._key] = value;
-	                    return this;
-	                };
-	                WeakMap.prototype.delete = function (target) {
-	                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);
-	                    return table !== undefined ? delete table[this._key] : false;
-	                };
-	                WeakMap.prototype.clear = function () {
-	                    // NOTE: not a real clear, just makes the previous data unreachable
-	                    this._key = CreateUniqueKey();
-	                };
-	                return WeakMap;
-	            }());
-	            function CreateUniqueKey() {
-	                var key;
-	                do
-	                    key = "@@WeakMap@@" + CreateUUID();
-	                while (HashMap.has(keys, key));
-	                keys[key] = true;
-	                return key;
-	            }
-	            function GetOrCreateWeakMapTable(target, create) {
-	                if (!hasOwn.call(target, rootKey)) {
-	                    if (!create)
-	                        return undefined;
-	                    Object.defineProperty(target, rootKey, { value: HashMap.create() });
-	                }
-	                return target[rootKey];
-	            }
-	            function FillRandomBytes(buffer, size) {
-	                for (var i = 0; i < size; ++i)
-	                    buffer[i] = Math.random() * 0xff | 0;
-	                return buffer;
-	            }
-	            function GenRandomBytes(size) {
-	                if (typeof Uint8Array === "function") {
-	                    if (typeof crypto !== "undefined")
-	                        return crypto.getRandomValues(new Uint8Array(size));
-	                    if (typeof msCrypto !== "undefined")
-	                        return msCrypto.getRandomValues(new Uint8Array(size));
-	                    return FillRandomBytes(new Uint8Array(size), size);
-	                }
-	                return FillRandomBytes(new Array(size), size);
-	            }
-	            function CreateUUID() {
-	                var data = GenRandomBytes(UUID_SIZE);
-	                // mark as random - RFC 4122 § 4.4
-	                data[6] = data[6] & 0x4f | 0x40;
-	                data[8] = data[8] & 0xbf | 0x80;
-	                var result = "";
-	                for (var offset = 0; offset < UUID_SIZE; ++offset) {
-	                    var byte = data[offset];
-	                    if (offset === 4 || offset === 6 || offset === 8)
-	                        result += "-";
-	                    if (byte < 16)
-	                        result += "0";
-	                    result += byte.toString(16).toLowerCase();
-	                }
-	                return result;
-	            }
-	        }
-	        // uses a heuristic used by v8 and chakra to force an object into dictionary mode.
-	        function MakeDictionary(obj) {
-	            obj.__ = undefined;
-	            delete obj.__;
-	            return obj;
-	        }
-	    });
-	})(Reflect || (Reflect = {}));
-	return _Reflect;
+/**
+ * 性能缓存模块 - 提供多层次缓存和性能监控
+ * @author richen
+ */
+/**
+ * 元数据缓存
+ */
+class MetadataCache {
+    constructor() {
+        this.cache = new WeakMap();
+    }
+    static getInstance() {
+        if (!MetadataCache.instance) {
+            MetadataCache.instance = new MetadataCache();
+        }
+        return MetadataCache.instance;
+    }
+    /**
+     * 获取类的元数据缓存
+     */
+    getClassCache(target) {
+        if (!this.cache.has(target)) {
+            this.cache.set(target, new Map());
+        }
+        return this.cache.get(target);
+    }
+    /**
+     * 缓存元数据
+     */
+    setMetadata(target, key, value) {
+        const classCache = this.getClassCache(target);
+        classCache.set(key, value);
+    }
+    /**
+     * 获取缓存的元数据
+     */
+    getMetadata(target, key) {
+        const classCache = this.getClassCache(target);
+        return classCache.get(key);
+    }
+    /**
+     * 检查是否已缓存
+     */
+    hasMetadata(target, key) {
+        const classCache = this.getClassCache(target);
+        return classCache.has(key);
+    }
+    /**
+     * 清空指定类的缓存
+     */
+    clearClassCache(target) {
+        if (this.cache.has(target)) {
+            this.cache.delete(target);
+        }
+    }
+}
+/**
+ * 验证结果缓存
+ */
+class ValidationCache {
+    constructor(options) {
+        this.hits = 0;
+        this.misses = 0;
+        this.cache = new lruCache.LRUCache({
+            max: (options === null || options === void 0 ? void 0 : options.max) || 5000,
+            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 10, // 10分钟
+            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
+            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
+        });
+    }
+    static getInstance(options) {
+        if (!ValidationCache.instance) {
+            ValidationCache.instance = new ValidationCache(options);
+        }
+        return ValidationCache.instance;
+    }
+    /**
+     * 生成缓存键
+     */
+    generateKey(validator, value, ...args) {
+        const valueStr = this.serializeValue(value);
+        const argsStr = args.length > 0 ? JSON.stringify(args) : '';
+        return `${validator}:${valueStr}:${argsStr}`;
+    }
+    /**
+     * 序列化值用于缓存键
+     */
+    serializeValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string')
+            return `s:${value}`;
+        if (typeof value === 'number')
+            return `n:${value}`;
+        if (typeof value === 'boolean')
+            return `b:${value}`;
+        if (Array.isArray(value))
+            return `a:${JSON.stringify(value)}`;
+        if (typeof value === 'object')
+            return `o:${JSON.stringify(value)}`;
+        return String(value);
+    }
+    /**
+     * 获取缓存的验证结果
+     */
+    get(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        const result = this.cache.get(key);
+        // Track cache hits and misses
+        if (result !== undefined) {
+            this.hits++;
+        }
+        else {
+            this.misses++;
+        }
+        return result;
+    }
+    /**
+     * 缓存验证结果
+     */
+    set(validator, value, result, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        this.cache.set(key, result);
+    }
+    /**
+     * 检查是否存在缓存
+     */
+    has(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.has(key);
+    }
+    /**
+     * 删除特定缓存
+     */
+    delete(validator, value, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        return this.cache.delete(key);
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * 获取缓存统计
+     */
+    getStats() {
+        const totalRequests = this.hits + this.misses;
+        const hitRate = totalRequests > 0 ? this.hits / totalRequests : 0;
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+            keyCount: this.cache.size,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: Math.round(hitRate * 10000) / 100, // Percentage with 2 decimal places
+            totalRequests,
+        };
+    }
+    /**
+     * 设置缓存TTL
+     */
+    setTTL(validator, value, ttl, ...args) {
+        const key = this.generateKey(validator, value, ...args);
+        const existingValue = this.cache.get(key);
+        if (existingValue !== undefined) {
+            this.cache.set(key, existingValue, { ttl });
+        }
+    }
+}
+/**
+ * 正则表达式缓存
+ */
+class RegexCache {
+    constructor(options) {
+        this.cache = new lruCache.LRUCache({
+            max: (options === null || options === void 0 ? void 0 : options.max) || 200,
+            ttl: (options === null || options === void 0 ? void 0 : options.ttl) || 1000 * 60 * 30, // 30分钟
+            allowStale: (options === null || options === void 0 ? void 0 : options.allowStale) || false,
+            updateAgeOnGet: (options === null || options === void 0 ? void 0 : options.updateAgeOnGet) || true,
+        });
+    }
+    static getInstance(options) {
+        if (!RegexCache.instance) {
+            RegexCache.instance = new RegexCache(options);
+        }
+        return RegexCache.instance;
+    }
+    /**
+     * 获取缓存的正则表达式
+     */
+    get(pattern, flags) {
+        const key = flags ? `${pattern}:::${flags}` : pattern;
+        let regex = this.cache.get(key);
+        if (!regex) {
+            try {
+                regex = new RegExp(pattern, flags);
+                this.cache.set(key, regex);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (_error) {
+                // 如果正则表达式无效，抛出错误
+                throw new Error(`Invalid regex pattern: ${pattern}`);
+            }
+        }
+        return regex;
+    }
+    /**
+     * 预编译常用正则表达式
+     */
+    precompile(patterns) {
+        patterns.forEach(({ pattern, flags }) => {
+            try {
+                this.get(pattern, flags);
+            }
+            catch (error) {
+                console.warn(`Failed to precompile regex: ${pattern}`, error);
+            }
+        });
+    }
+    /**
+     * 获取缓存统计
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+        };
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+/**
+ * 性能监控
+ */
+class PerformanceMonitor {
+    constructor() {
+        this.metrics = new Map();
+    }
+    static getInstance() {
+        if (!PerformanceMonitor.instance) {
+            PerformanceMonitor.instance = new PerformanceMonitor();
+        }
+        return PerformanceMonitor.instance;
+    }
+    /**
+     * 开始计时
+     */
+    startTimer(name) {
+        const start = performance.now();
+        return () => {
+            const duration = performance.now() - start;
+            this.recordMetric(name, duration);
+        };
+    }
+    /**
+     * 记录性能指标
+     */
+    recordMetric(name, duration) {
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, {
+                count: 0,
+                totalTime: 0,
+                avgTime: 0,
+                maxTime: 0,
+                minTime: Infinity,
+                lastExecutionTime: new Date(),
+            });
+        }
+        const metric = this.metrics.get(name);
+        metric.count++;
+        metric.totalTime += duration;
+        metric.avgTime = metric.totalTime / metric.count;
+        metric.maxTime = Math.max(metric.maxTime, duration);
+        metric.minTime = Math.min(metric.minTime, duration);
+        metric.lastExecutionTime = new Date();
+    }
+    /**
+     * 获取性能报告
+     */
+    getReport() {
+        const report = {};
+        for (const [name, metric] of this.metrics) {
+            report[name] = {
+                ...metric,
+                minTime: metric.minTime === Infinity ? 0 : metric.minTime,
+                avgTimeFormatted: `${metric.avgTime.toFixed(2)}ms`,
+                totalTimeFormatted: `${metric.totalTime.toFixed(2)}ms`,
+            };
+        }
+        return report;
+    }
+    /**
+     * 获取热点分析（执行时间最长的操作）
+     */
+    getHotspots(limit = 10) {
+        return Array.from(this.metrics.entries())
+            .map(([name, metric]) => ({
+            name,
+            avgTime: metric.avgTime,
+            count: metric.count,
+        }))
+            .sort((a, b) => b.avgTime - a.avgTime)
+            .slice(0, limit);
+    }
+    /**
+     * 清空指标
+     */
+    clear() {
+        this.metrics.clear();
+    }
+    /**
+     * 导出性能数据为CSV格式
+     */
+    exportToCSV() {
+        const headers = ['Name', 'Count', 'Total Time (ms)', 'Avg Time (ms)', 'Max Time (ms)', 'Min Time (ms)', 'Last Execution'];
+        const rows = [headers.join(',')];
+        for (const [name, metric] of this.metrics) {
+            const row = [
+                name,
+                metric.count.toString(),
+                metric.totalTime.toFixed(2),
+                metric.avgTime.toFixed(2),
+                metric.maxTime.toFixed(2),
+                (metric.minTime === Infinity ? 0 : metric.minTime).toFixed(2),
+                metric.lastExecutionTime.toISOString(),
+            ];
+            rows.push(row.join(','));
+        }
+        return rows.join('\n');
+    }
+}
+// 导出单例实例
+const metadataCache = MetadataCache.getInstance();
+const validationCache = ValidationCache.getInstance();
+const regexCache = RegexCache.getInstance();
+const performanceMonitor = PerformanceMonitor.getInstance();
+/**
+ * 缓存装饰器 - 用于缓存验证函数结果
+ */
+function cached(validator, ttl) {
+    return function (target, propertyName, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const value = args[0];
+            const additionalArgs = args.slice(1);
+            // 尝试从缓存获取结果
+            const cachedResult = validationCache.get(validator, value, ...additionalArgs);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            // 执行验证并缓存结果
+            const endTimer = performanceMonitor.startTimer(validator);
+            try {
+                const result = originalMethod.apply(this, args);
+                validationCache.set(validator, value, result, ...additionalArgs);
+                // 如果指定了TTL，设置过期时间
+                if (ttl && ttl > 0) {
+                    validationCache.setTTL(validator, value, ttl, ...additionalArgs);
+                }
+                return result;
+            }
+            finally {
+                endTimer();
+            }
+        };
+        return descriptor;
+    };
+}
+/**
+ * 获取所有缓存统计信息
+ */
+function getAllCacheStats() {
+    return {
+        validation: validationCache.getStats(),
+        regex: regexCache.getStats(),
+        performance: performanceMonitor.getReport(),
+        hotspots: performanceMonitor.getHotspots(),
+    };
+}
+/**
+ * 预热缓存 - 预编译常用正则表达式
+ */
+function warmupCaches() {
+    // 预编译中文验证相关的正则表达式
+    const commonPatterns = [
+        { pattern: '^[\u4e00-\u9fa5]{2,8}$' }, // 中文姓名
+        { pattern: '^1[3-9]\\d{9}$' }, // 手机号
+        { pattern: '^\\d{6}$' }, // 邮政编码
+        { pattern: '^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼]' }, // 车牌号开头
+    ];
+    regexCache.precompile(commonPatterns);
+}
+/**
+ * 清空所有缓存
+ */
+function clearAllCaches() {
+    validationCache.clear();
+    regexCache.clear();
+    performanceMonitor.clear();
+}
+/**
+ * 配置缓存设置
+ */
+function configureCaches(options) {
+    if (options.validation) {
+        // 重新创建验证缓存实例
+        ValidationCache.instance = new ValidationCache(options.validation);
+    }
+    if (options.regex) {
+        // 重新创建正则缓存实例
+        RegexCache.instance = new RegexCache(options.regex);
+    }
 }
-
-require_Reflect();
 
 /**
  * @ author: richen
@@ -1573,10 +602,18 @@ function convertParamsType(param, type) {
                     return NaN;
                 }
                 if (helper__namespace.isNumber(param)) {
+                    // Check for safe integer range
+                    if (Number.isInteger(param) && !Number.isSafeInteger(param)) {
+                        console.warn(`[koatty_validation] Number ${param} exceeds safe integer range`);
+                    }
                     return param;
                 }
                 if (helper__namespace.isNumberString(param)) {
-                    return helper__namespace.toNumber(param);
+                    const num = helper__namespace.toNumber(param);
+                    if (Number.isInteger(num) && !Number.isSafeInteger(num)) {
+                        console.warn(`[koatty_validation] Number ${param} exceeds safe integer range`);
+                    }
+                    return num;
                 }
                 return NaN;
             case "Boolean":
@@ -1613,9 +650,10 @@ function convertParamsType(param, type) {
             default: //any
                 return param;
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
-    catch (err) {
+    catch (error) {
+        // Log conversion errors for debugging
+        console.warn(`[koatty_validation] Type conversion error for type "${type}":`, error instanceof Error ? error.message : String(error));
         return param;
     }
 }
@@ -1691,7 +729,12 @@ function checkParamsType(value, type) {
  * @returns {boolean}
  */
 function cnName(value) {
-    const reg = /^([a-zA-Z0-9\u4e00-\u9fa5\·]{1,10})$/;
+    // Add length limit for security
+    if (value.length > 50) {
+        return false;
+    }
+    // Use regex cache for better performance
+    const reg = regexCache.get('^([a-zA-Z0-9\\u4e00-\\u9fa5\\·]{1,10})$');
     return reg.test(value);
 }
 /**
@@ -1701,10 +744,18 @@ function cnName(value) {
  * @returns
  */
 function idNumber(value) {
-    if (/^\d{15}$/.test(value)) {
+    // Add length limit for security
+    if (!value || value.length > 20) {
+        return false;
+    }
+    // Check 15-digit ID
+    const reg15 = regexCache.get('^\\d{15}$');
+    if (reg15.test(value)) {
         return true;
     }
-    if ((/^\d{17}[0-9X]$/).test(value)) {
+    // Check 18-digit ID with validation
+    const reg18 = regexCache.get('^\\d{17}[0-9X]$');
+    if (reg18.test(value)) {
         const vs = '1,0,x,9,8,7,6,5,4,3,2'.split(',');
         const ps = '7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2'.split(',');
         const ss = value.toLowerCase().split('');
@@ -1724,7 +775,11 @@ function idNumber(value) {
  * @returns {boolean}
  */
 function mobile(value) {
-    const reg = /^(13|14|15|16|17|18|19)\d{9}$/;
+    // Add length limit for security (prevent ReDoS)
+    if (!value || value.length > 20) {
+        return false;
+    }
+    const reg = regexCache.get('^(13|14|15|16|17|18|19)\\d{9}$');
     return reg.test(value);
 }
 /**
@@ -1734,7 +789,11 @@ function mobile(value) {
  * @returns {boolean}
  */
 function zipCode(value) {
-    const reg = /^\d{6}$/;
+    // Add length limit for security
+    if (!value || value.length > 10) {
+        return false;
+    }
+    const reg = regexCache.get('^\\d{6}$');
     return reg.test(value);
 }
 /**
@@ -1744,16 +803,19 @@ function zipCode(value) {
  * @returns {boolean}
  */
 function plateNumber(value) {
-    // let reg = new RegExp('^(([\u4e00-\u9fa5][a-zA-Z]|[\u4e00-\u9fa5]{2}\d{2}|[\u4e00-\u9fa5]{2}[a-zA-Z])[-]?|([wW][Jj][\u4e00-\u9fa5]{1}[-]?)|([a-zA-Z]{2}))([A-Za-z0-9]{5}|[DdFf][A-HJ-NP-Za-hj-np-z0-9][0-9]{4}|[0-9]{5}[DdFf])$');
-    // let xReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
-    const xReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
-    // let cReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
-    const cReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
+    // Add length limit for security
+    if (!value || value.length > 15) {
+        return false;
+    }
+    // New energy vehicle plate number (8 characters)
+    const xReg = regexCache.get('^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))');
+    // Traditional vehicle plate number (7 characters)
+    const cReg = regexCache.get('^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$');
     if (value.length === 7) {
         return cReg.test(value);
     }
     else {
-        //新能源车牌
+        // New energy vehicle plate
         return xReg.test(value);
     }
 }
@@ -1763,10 +825,9 @@ function plateNumber(value) {
  * @Usage:
  * @Author: richen
  * @Date: 2021-11-25 10:47:04
- * @LastEditTime: 2024-10-31 16:57:28
+ * @LastEditTime: 2024-01-03 14:32:49
  */
 // constant
-const PARAM_TYPE_KEY = 'PARAM_TYPE_KEY';
 const PARAM_RULE_KEY = 'PARAM_RULE_KEY';
 const PARAM_CHECK_KEY = 'PARAM_CHECK_KEY';
 const ENABLE_VALIDATED = "ENABLE_VALIDATED";
@@ -1800,7 +861,6 @@ exports.paramterTypes = void 0;
     paramterTypes[paramterTypes["undefined"] = 19] = "undefined";
 })(exports.paramterTypes || (exports.paramterTypes = {}));
 class ValidateClass {
-    static instance;
     constructor() {
     }
     /**
@@ -1823,10 +883,20 @@ class ValidateClass {
      * @memberof ValidateClass
      */
     async valid(Clazz, data, convert = false) {
-        const obj = data instanceof Clazz ? data : plainToClass(Clazz, data, convert);
-        const errors = convert
-            ? await classValidator.validate(obj)
-            : await classValidator.validate(obj, { skipMissingProperties: true });
+        let obj = {};
+        if (data instanceof Clazz) {
+            obj = data;
+        }
+        else {
+            obj = plainToClass(Clazz, data, convert);
+        }
+        let errors = [];
+        if (convert) {
+            errors = await classValidator.validate(obj);
+        }
+        else {
+            errors = await classValidator.validate(obj, { skipMissingProperties: true });
+        }
         if (errors.length > 0) {
             throw new Error(Object.values(errors[0].constraints)[0]);
         }
@@ -1837,6 +907,23 @@ class ValidateClass {
  * ClassValidator for manual
  */
 const ClassValidator = ValidateClass.getInstance();
+/**
+ * Helper function to wrap validation with cache
+ */
+function withCache(validatorName, validatorFunc) {
+    return (value, ...args) => {
+        // Check cache first
+        const cached = validationCache.get(validatorName, value, ...args);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Execute validation
+        const result = validatorFunc(value, ...args);
+        // Cache the result
+        validationCache.set(validatorName, value, result, ...args);
+        return result;
+    };
+}
 /**
  * Validator Functions
  */
@@ -1845,27 +932,27 @@ const ValidFuncs = {
      * Checks value is not empty, undefined, null, '', NaN, [], {} and any empty string(including spaces,
      * tabs, formfeeds, etc.), returns false
      */
-    IsNotEmpty: (value) => {
+    IsNotEmpty: withCache('IsNotEmpty', (value) => {
         return !helper__namespace.isEmpty(value);
-    },
+    }),
     /**
      * Checks if a given value is a real date.
      */
-    IsDate: (value) => {
+    IsDate: withCache('IsDate', (value) => {
         return helper__namespace.isDate(value);
-    },
+    }),
     /**
      * Checks if the string is an email. If given value is not a string, then it returns false.
      */
-    IsEmail: (value, options) => {
+    IsEmail: withCache('IsEmail', (value, options) => {
         return classValidator.isEmail(value, options);
-    },
+    }),
     /**
      * Checks if the string is an IP (version 4 or 6). If given value is not a string, then it returns false.
      */
-    IsIP: (value, version) => {
+    IsIP: withCache('IsIP', (value, version) => {
         return classValidator.isIP(value, version);
-    },
+    }),
     /**
      * Checks if the string is a valid phone number.
      * @param value — the potential phone number string to test
@@ -1874,875 +961,576 @@ const ValidFuncs = {
      * See [google-libphonenumber, metadata.js:countryCodeToRegionCodeMap on github]
      * {@link https://github.com/ruimarinho/google-libphonenumber/blob/1e46138878cff479aafe2ce62175c6c49cb58720/src/metadata.js#L33}
      */
-    IsPhoneNumber: (value, region) => {
+    IsPhoneNumber: withCache('IsPhoneNumber', (value, region) => {
         return classValidator.isPhoneNumber(value, region);
-    },
+    }),
     /**
      * Checks if the string is an url. If given value is not a string, then it returns false.
      */
-    IsUrl: (value, options) => {
+    IsUrl: withCache('IsUrl', (value, options) => {
         return classValidator.isURL(value, options);
-    },
+    }),
     /**
      * check if the string is a hash of type algorithm. Algorithm is one of
      * ['md4', 'md5', 'sha1', 'sha256', 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
      */
-    IsHash: (value, algorithm) => {
+    IsHash: withCache('IsHash', (value, algorithm) => {
         return classValidator.isHash(value, algorithm);
-    },
+    }),
     /**
      * Checks if value is a chinese name.
      */
-    IsCnName: (value) => {
+    IsCnName: withCache('IsCnName', (value) => {
         if (!helper__namespace.isString(value)) {
             return false;
         }
         return cnName(value);
-    },
+    }),
     /**
      * Checks if value is a idcard number.
      */
-    IsIdNumber: (value) => {
+    IsIdNumber: withCache('IsIdNumber', (value) => {
         if (!helper__namespace.isString(value)) {
             return false;
         }
         return idNumber(value);
-    },
+    }),
     /**
      * Checks if value is a zipCode.
      */
-    IsZipCode: (value) => {
+    IsZipCode: withCache('IsZipCode', (value) => {
         if (!helper__namespace.isString(value)) {
             return false;
         }
         return zipCode(value);
-    },
+    }),
     /**
      * Checks if value is a mobile phone number.
      */
-    IsMobile: (value) => {
+    IsMobile: withCache('IsMobile', (value) => {
         if (!helper__namespace.isString(value)) {
             return false;
         }
         return mobile(value);
-    },
+    }),
     /**
      * Checks if value is a plateNumber.
      */
-    IsPlateNumber: (value) => {
+    IsPlateNumber: withCache('IsPlateNumber', (value) => {
         if (!helper__namespace.isString(value)) {
             return false;
         }
         return plateNumber(value);
-    },
+    }),
     /**
      * Checks if value matches ("===") the comparison.
      */
-    Equals: (value, comparison) => {
+    Equals: withCache('Equals', (value, comparison) => {
         return classValidator.equals(value, comparison);
-    },
+    }),
     /**
      * Checks if value does not match ("!==") the comparison.
      */
-    NotEquals: (value, comparison) => {
+    NotEquals: withCache('NotEquals', (value, comparison) => {
         return classValidator.notEquals(value, comparison);
-    },
+    }),
     /**
      * Checks if the string contains the seed. If given value is not a string, then it returns false.
      */
-    Contains: (value, seed) => {
+    Contains: withCache('Contains', (value, seed) => {
         return classValidator.contains(value, seed);
-    },
+    }),
     /**
      * Checks if given value is in a array of allowed values.
      */
-    IsIn: (value, possibleValues) => {
+    IsIn: withCache('IsIn', (value, possibleValues) => {
         return classValidator.isIn(value, possibleValues);
-    },
+    }),
     /**
      * Checks if given value not in a array of allowed values.
      */
-    IsNotIn: (value, possibleValues) => {
+    IsNotIn: withCache('IsNotIn', (value, possibleValues) => {
         return classValidator.isNotIn(value, possibleValues);
-    },
+    }),
     /**
      * Checks if the first number is greater than or equal to the second.
      */
-    Gt: (num, min) => {
+    Gt: withCache('Gt', (num, min) => {
         return helper__namespace.toNumber(num) > min;
-    },
+    }),
     /**
      * Checks if the first number is less than or equal to the second.
      */
-    Lt: (num, max) => {
+    Lt: withCache('Lt', (num, max) => {
         return helper__namespace.toNumber(num) < max;
-    },
+    }),
     /**
      * Checks if the first number is greater than or equal to the second.
      */
-    Gte: (num, min) => {
+    Gte: withCache('Gte', (num, min) => {
         return helper__namespace.toNumber(num) >= min;
-    },
+    }),
     /**
      * Checks if the first number is less than or equal to the second.
      */
-    Lte: (num, max) => {
+    Lte: withCache('Lte', (num, max) => {
         return helper__namespace.toNumber(num) <= max;
-    },
+    }),
 };
 /**
- * Use functions or built-in rules for validation.
- *
- * @export
- * @param {ValidRules} rule
- * @param {unknown} value
- * @param {(string | ValidOtpions)} [options]
- * @returns {*}
+ * Helper function to create validator function
  */
-const FunctionValidator = {};
-Object.keys(ValidFuncs).forEach((key) => {
-    FunctionValidator[key] = (value, options) => {
-        if (helper__namespace.isString(options)) {
-            options = { message: options, value: null };
-        }
-        if (!ValidFuncs[key](value, options.value)) {
-            throw new Error(options.message || `ValidatorError: invalid arguments.`);
+function createValidatorFunction(validatorFunc, defaultMessage) {
+    return (value, options) => {
+        let validOptions;
+        if (typeof options === 'string') {
+            validOptions = { message: options, value: null };
         }
-    };
-});
-
-/*
- * @Description:
- * @Usage:
- * @Author: richen
- * @Date: 2021-11-25 10:46:57
- * @LastEditTime: 2024-10-31 16:49:26
- */
-/**
- * Validation parameter's type and values.
- *
- * @export
- * @param {(ValidRules | ValidRules[] | Function)} rule
- * @param {*} [options] If the options type is a string, the value is the error message of the validation rule.
- * Some validation rules require additional parameters, ext: @Valid("Gte", {message:"Requires value greater than or equal to 100", value: 100})
- * @returns {*}  {ParameterDecorator}
- */
-function Valid(rule, options) {
-    let rules = [];
-    if (helper__namespace.isString(rule)) {
-        rules = rule.split(",");
-    }
-    else {
-        rules = rule;
-    }
-    return (target, propertyKey, descriptor) => {
-        // 获取成员参数类型
-        const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
-        const type = (paramTypes[descriptor]?.name) ? paramTypes[descriptor].name : 'object';
-        if (helper__namespace.isString(options)) {
-            options = { message: options, value: null };
+        else {
+            validOptions = options || { message: defaultMessage, value: null };
         }
-        koatty_container.IOCContainer.attachPropertyData(PARAM_RULE_KEY, {
-            name: propertyKey,
-            rule: rules,
-            options,
-            index: descriptor,
-            type
-        }, target, propertyKey);
-    };
-}
-/**
- * Validation parameter's type and values from DTO class.
- *
- * @export
- * @returns {MethodDecorator}
- */
-function Validated() {
-    return (target, propertyKey, _descriptor) => {
-        //
-        koatty_container.IOCContainer.savePropertyData(PARAM_CHECK_KEY, {
-            dtoCheck: 1
-        }, target, propertyKey);
-        // 获取成员参数类型
-        // const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
-        // const { value, configurable, enumerable } = descriptor;
-        // descriptor = {
-        //     configurable,
-        //     enumerable,
-        //     writable: true,
-        //     value: async function valid(...props: any[]) {
-        //         const ps: any[] = [];
-        //         // tslint:disable-next-line: no-unused-expression
-        //         (props || []).map((value: any, index: number) => {
-        //             const type = (paramTypes[index] && paramTypes[index].name) ? paramTypes[index].name : "any";
-        //             if (!paramterTypes[type]) {
-        //                 ps.push(ClassValidator.valid(paramTypes[index], value, true));
-        //             } else {
-        //                 ps.push(Promise.resolve(value));
-        //             }
-        //         });
-        //         if (ps.length > 0) {
-        //             props = await Promise.all(ps);
-        //         }
-        //         // tslint:disable-next-line: no-invalid-this
-        //         return value.apply(this, props);
-        //     }
-        // };
-        // return descriptor;
-    };
-}
-/**
- * Marks property as included in the process of transformation.
- *
- * @export
- * @returns {PropertyDecorator}
- */
-function Expose() {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-    };
-}
-/**
- * Alias of Expose
- *
- * @export
- * @returns {PropertyDecorator}
- */
-function IsDefined() {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-    };
-}
-/**
- * Checks if value is a chinese name.
- *
- * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
- */
-function IsCnName(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "IsCnName",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return cnName(value);
-                },
-                defaultMessage(_args) {
-                    return "invalid parameter ($property).";
-                }
+        if (!validatorFunc(value, validOptions.value)) {
+            // Priority: validOptions.message -> defaultMessage -> fallback error
+            let errorMessage = validOptions.message;
+            // If message is empty or whitespace, use defaultMessage
+            if (!errorMessage || !errorMessage.trim()) {
+                errorMessage = defaultMessage;
             }
-        });
-    };
-}
-/**
- * Checks if value is a idCard number(chinese).
- *
- * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
- */
-function IsIdNumber(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "IsIdNumber",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return idNumber(value);
-                },
-                defaultMessage(_args) {
-                    return "invalid parameter ($property).";
-                }
+            // If defaultMessage is also empty, use fallback
+            if (!errorMessage || !errorMessage.trim()) {
+                errorMessage = 'ValidatorError: invalid arguments.';
             }
-        });
+            throw new Error(errorMessage);
+        }
     };
 }
 /**
- * Checks if value is a zipCode(chinese).
+ * Use functions or built-in rules for validation.
+ * Throws error if validation fails.
  *
  * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
  */
-function IsZipCode(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "IsZipCode",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return zipCode(value);
-                },
-                defaultMessage(_args) {
-                    return "invalid parameter ($property).";
-                }
-            }
-        });
-    };
-}
+const FunctionValidator = {
+    IsNotEmpty: createValidatorFunction(ValidFuncs.IsNotEmpty, 'Value should not be empty'),
+    IsDate: createValidatorFunction(ValidFuncs.IsDate, 'Must be a valid date'),
+    IsEmail: createValidatorFunction(ValidFuncs.IsEmail, 'Must be a valid email'),
+    IsIP: createValidatorFunction(ValidFuncs.IsIP, 'Must be a valid IP address'),
+    IsPhoneNumber: createValidatorFunction(ValidFuncs.IsPhoneNumber, 'Must be a valid phone number'),
+    IsUrl: createValidatorFunction(ValidFuncs.IsUrl, 'Must be a valid URL'),
+    IsHash: createValidatorFunction(ValidFuncs.IsHash, 'Must be a valid hash'),
+    IsCnName: createValidatorFunction(ValidFuncs.IsCnName, 'Must be a valid Chinese name'),
+    IsIdNumber: createValidatorFunction(ValidFuncs.IsIdNumber, 'Must be a valid ID number'),
+    IsZipCode: createValidatorFunction(ValidFuncs.IsZipCode, 'Must be a valid zip code'),
+    IsMobile: createValidatorFunction(ValidFuncs.IsMobile, 'Must be a valid mobile number'),
+    IsPlateNumber: createValidatorFunction(ValidFuncs.IsPlateNumber, 'Must be a valid plate number'),
+    Equals: createValidatorFunction(ValidFuncs.Equals, 'Values must be equal'),
+    NotEquals: createValidatorFunction(ValidFuncs.NotEquals, 'Values must not be equal'),
+    Contains: createValidatorFunction(ValidFuncs.Contains, 'Value must contain specified substring'),
+    IsIn: createValidatorFunction(ValidFuncs.IsIn, 'Value must be in the allowed list'),
+    IsNotIn: createValidatorFunction(ValidFuncs.IsNotIn, 'Value must not be in the forbidden list'),
+    Gt: createValidatorFunction(ValidFuncs.Gt, 'Value must be greater than threshold'),
+    Lt: createValidatorFunction(ValidFuncs.Lt, 'Value must be less than threshold'),
+    Gte: createValidatorFunction(ValidFuncs.Gte, 'Value must be greater than or equal to threshold'),
+    Lte: createValidatorFunction(ValidFuncs.Lte, 'Value must be less than or equal to threshold'),
+};
+
 /**
- * Checks if value is a mobile phone number(chinese).
- *
- * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 装饰器工厂 - 消除装饰器代码重复
+ * @author richen
  */
-function IsMobile(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "IsMobile",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return mobile(value);
-                },
-                defaultMessage(_args) {
-                    return "invalid parameter ($property).";
-                }
-            }
-        });
-    };
-}
 /**
- * Checks if value is a plate number(chinese).
- *
- * @export
- * @param {string} property
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 创建验证装饰器的工厂函数
+ * @param options 装饰器配置选项
+ * @returns 装饰器工厂函数
  */
-function IsPlateNumber(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "IsPlateNumber",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return plateNumber(value);
-                },
-                defaultMessage(_args) {
-                    return "invalid parameter ($property).";
+function createValidationDecorator(options) {
+    const { name, validator, defaultMessage, requiresValue = false } = options;
+    return function decoratorFactory(...args) {
+        // 处理参数：最后一个参数是ValidationOptions，前面是验证函数的参数
+        const validationOptions = args[args.length - 1];
+        const validatorArgs = requiresValue ? args.slice(0, -1) : [];
+        return function propertyDecorator(object, propertyName) {
+            // 设置属性为可导出
+            setExpose(object, propertyName);
+            // 注册验证装饰器
+            classValidator.registerDecorator({
+                name,
+                target: object.constructor,
+                propertyName,
+                options: validationOptions,
+                constraints: validatorArgs,
+                validator: {
+                    validate(value) {
+                        try {
+                            return validator(value, ...validatorArgs);
+                        }
+                        catch {
+                            return false;
+                        }
+                    },
+                    defaultMessage(validationArguments) {
+                        const property = validationArguments.property;
+                        return defaultMessage
+                            ? defaultMessage.replace('$property', property)
+                            : `Invalid value for ${property}`;
+                    }
                 }
-            }
-        });
+            });
+        };
     };
 }
 /**
- * Checks value is not empty, undefined, null, '', NaN, [], {} and any empty string(including spaces, tabs, formfeeds, etc.), returns false.
- *
- * @export
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 创建简单验证装饰器（不需要额外参数）
+ * @param name 装饰器名称
+ * @param validator 验证函数
+ * @param defaultMessage 默认错误信息
+ * @returns 装饰器函数
  */
-function IsNotEmpty(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "IsNotEmpty",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return !helper__namespace.isEmpty(value);
-                },
-                defaultMessage(_args) {
-                    return "invalid parameter ($property).";
-                }
-            }
-        });
-    };
-}
-/**
- * Checks if value matches ("===") the comparison.
- *
- * @export
- * @param {*} comparison
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
- */
-function Equals(comparison, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vEquals",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.equals(value, comparison);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter, ($property) must be equals ${comparison}.`;
-                }
-            }
-        });
-    };
+function createSimpleDecorator(name, validator, defaultMessage) {
+    return createValidationDecorator({
+        name,
+        validator,
+        defaultMessage,
+        requiresValue: false
+    });
 }
 /**
- * Checks if value does not match ("!==") the comparison.
- *
- * @export
- * @param {*} comparison
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 创建带参数的验证装饰器
+ * @param name 装饰器名称
+ * @param validator 验证函数
+ * @param defaultMessage 默认错误信息
+ * @returns 装饰器工厂函数
  */
-function NotEquals(comparison, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vNotEquals",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.notEquals(value, comparison);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter, ($property) must be not equals ${comparison}.`;
-                }
-            }
-        });
-    };
+function createParameterizedDecorator(name, validator, defaultMessage) {
+    return createValidationDecorator({
+        name,
+        validator,
+        defaultMessage,
+        requiresValue: true
+    });
 }
+
 /**
- * Checks if the string contains the seed.
- *
- * @export
- * @param {string} seed
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 改进的错误处理机制
+ * @author richen
  */
-function Contains(seed, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vContains",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.contains(value, seed);
-                    // return typeof value === "string" && (value.indexOf(seed) > -1);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter, ($property) must be contains ${seed}.`;
-                }
-            }
-        });
-    };
-}
 /**
- * Checks if given value is in a array of allowed values.
- *
- * @export
- * @param {any[]} possibleValues
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 错误信息国际化
  */
-function IsIn(possibleValues, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsIn",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isIn(value, possibleValues);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
-}
+const ERROR_MESSAGES = {
+    zh: {
+        // 中国本土化验证
+        IsCnName: '必须是有效的中文姓名',
+        IsIdNumber: '必须是有效的身份证号码',
+        IsZipCode: '必须是有效的邮政编码',
+        IsMobile: '必须是有效的手机号码',
+        IsPlateNumber: '必须是有效的车牌号码',
+        // 基础验证
+        IsNotEmpty: '不能为空',
+        IsDate: '必须是有效的日期',
+        IsEmail: '必须是有效的邮箱地址',
+        IsIP: '必须是有效的IP地址',
+        IsPhoneNumber: '必须是有效的电话号码',
+        IsUrl: '必须是有效的URL地址',
+        IsHash: '必须是有效的哈希值',
+        // 比较验证
+        Equals: '必须等于 {comparison}',
+        NotEquals: '不能等于 {comparison}',
+        Contains: '必须包含 {seed}',
+        IsIn: '必须是以下值之一: {possibleValues}',
+        IsNotIn: '不能是以下值之一: {possibleValues}',
+        Gt: '必须大于 {min}',
+        Gte: '必须大于或等于 {min}',
+        Lt: '必须小于 {max}',
+        Lte: '必须小于或等于 {max}',
+        // 通用错误
+        invalidParameter: '参数 {field} 无效',
+        validationFailed: '验证失败',
+    },
+    en: {
+        // Chinese localization validators
+        IsCnName: 'must be a valid Chinese name',
+        IsIdNumber: 'must be a valid ID number',
+        IsZipCode: 'must be a valid zip code',
+        IsMobile: 'must be a valid mobile number',
+        IsPlateNumber: 'must be a valid plate number',
+        // Basic validators
+        IsNotEmpty: 'should not be empty',
+        IsDate: 'must be a valid date',
+        IsEmail: 'must be a valid email',
+        IsIP: 'must be a valid IP address',
+        IsPhoneNumber: 'must be a valid phone number',
+        IsUrl: 'must be a valid URL',
+        IsHash: 'must be a valid hash',
+        // Comparison validators
+        Equals: 'must equal to {comparison}',
+        NotEquals: 'should not equal to {comparison}',
+        Contains: 'must contain {seed}',
+        IsIn: 'must be one of the following values: {possibleValues}',
+        IsNotIn: 'should not be one of the following values: {possibleValues}',
+        Gt: 'must be greater than {min}',
+        Gte: 'must be greater than or equal to {min}',
+        Lt: 'must be less than {max}',
+        Lte: 'must be less than or equal to {max}',
+        // Common errors
+        invalidParameter: 'invalid parameter {field}',
+        validationFailed: 'validation failed',
+    }
+};
 /**
- * Checks if given value not in a array of allowed values.
- *
- * @export
- * @param {any[]} possibleValues
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 增强的验证错误类
  */
-function IsNotIn(possibleValues, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsNotIn",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isNotIn(value, possibleValues);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
+class KoattyValidationError extends Error {
+    constructor(errors, message) {
+        const errorMessage = message || 'Validation failed';
+        super(errorMessage);
+        this.name = 'KoattyValidationError';
+        this.errors = errors;
+        this.statusCode = 400;
+        this.timestamp = new Date();
+        // 确保正确的原型链
+        Object.setPrototypeOf(this, KoattyValidationError.prototype);
+    }
+    /**
+     * 获取第一个错误信息
+     */
+    getFirstError() {
+        return this.errors[0];
+    }
+    /**
+     * 获取指定字段的错误
+     */
+    getFieldErrors(field) {
+        return this.errors.filter(error => error.field === field);
+    }
+    /**
+     * 转换为JSON格式
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            timestamp: this.timestamp,
+            errors: this.errors
+        };
+    }
 }
 /**
- * Checks if a given value is a real date.
- *
- * @export
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 错误信息格式化器
  */
-function IsDate(validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsDate",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isDate(value);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
+class ErrorMessageFormatter {
+    constructor(language = 'zh') {
+        this.language = 'zh';
+        this.language = language;
+    }
+    /**
+     * 设置语言
+     */
+    setLanguage(language) {
+        this.language = language;
+    }
+    /**
+     * 格式化错误消息
+     */
+    formatMessage(constraint, field, value, context) {
+        const messages = ERROR_MESSAGES[this.language];
+        let template = messages[constraint] || messages.invalidParameter;
+        // 替换占位符
+        template = template.replace('{field}', field);
+        // 优先使用上下文中的值，然后是传入的value
+        if (context) {
+            Object.entries(context).forEach(([key, val]) => {
+                template = template.replace(`{${key}}`, this.formatValue(val));
+            });
+        }
+        // 如果还有{value}占位符且传入了value，则替换
+        if (value !== undefined && template.includes('{value}')) {
+            template = template.replace('{value}', this.formatValue(value));
+        }
+        return template;
+    }
+    /**
+     * 格式化值用于消息显示
+     * @private
+     */
+    formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'string')
+            return `"${value}"`;
+        if (Array.isArray(value))
+            return `[${value.map(v => this.formatValue(v)).join(', ')}]`;
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
             }
-        });
-    };
-}
-/**
- * Checks if the first number is greater than or equal to the min value.
- *
- * @export
- * @param {number} min
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
- */
-function Gt(min, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vMin",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return helper__namespace.toNumber(value) > min;
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
+            catch {
+                // 处理循环引用
+                return '[Circular Reference]';
             }
-        });
-    };
+        }
+        return String(value);
+    }
 }
 /**
- * Checks if the first number is less than or equal to the max value.
- *
- * @export
- * @param {number} max
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 全局错误信息格式化器实例
  */
-function Lt(max, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vMax",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return helper__namespace.toNumber(value) < max;
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
-}
+const errorFormatter = new ErrorMessageFormatter();
 /**
- * Checks if the first number is greater than or equal to the min value.
- *
- * @export
- * @param {number} min
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 设置全局语言
  */
-function Gte(min, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vMin",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return helper__namespace.toNumber(value) >= min;
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
+function setValidationLanguage(language) {
+    errorFormatter.setLanguage(language);
 }
 /**
- * Checks if the first number is less than or equal to the max value.
- *
- * @export
- * @param {number} max
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 创建验证错误
  */
-function Lte(max, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vMax",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return helper__namespace.toNumber(value) <= max;
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
+function createValidationError(field, value, constraint, customMessage, context) {
+    const message = customMessage || errorFormatter.formatMessage(constraint, field, value, context);
+    return {
+        field,
+        value,
+        constraint,
+        message,
+        context
     };
 }
 /**
- * Checks if the string's length falls in a range. Note: this function takes into account surrogate pairs.
- * If given value is not a string, then it returns false.
- *
- * @export
- * @param {number} min
- * @param {number} [max]
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 批量创建验证错误
  */
-function Length(min, max, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vLength",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.length(value, min, max);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
+function createValidationErrors(errors) {
+    const validationErrors = errors.map(error => createValidationError(error.field, error.value, error.constraint, error.message, error.context));
+    return new KoattyValidationError(validationErrors);
 }
+
 /**
- * Checks if the string is an email. If given value is not a string, then it returns false.
- *
- * @export
- * @param {IsEmailOptions} [options]
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 重构后的装饰器定义 - 使用工厂函数消除重复
+ * @author richen
  */
+// 中国本土化验证装饰器
+const IsCnName = createSimpleDecorator('IsCnName', (value) => helper__namespace.isString(value) && cnName(value), 'must be a valid Chinese name');
+const IsIdNumber = createSimpleDecorator('IsIdNumber', (value) => helper__namespace.isString(value) && idNumber(value), 'must be a valid ID number');
+const IsZipCode = createSimpleDecorator('IsZipCode', (value) => helper__namespace.isString(value) && zipCode(value), 'must be a valid zip code');
+const IsMobile = createSimpleDecorator('IsMobile', (value) => helper__namespace.isString(value) && mobile(value), 'must be a valid mobile number');
+const IsPlateNumber = createSimpleDecorator('IsPlateNumber', (value) => helper__namespace.isString(value) && plateNumber(value), 'must be a valid plate number');
+// 基础验证装饰器
+const IsNotEmpty = createSimpleDecorator('IsNotEmpty', (value) => !helper__namespace.isEmpty(value), 'should not be empty');
+const IsDate = createSimpleDecorator('IsDate', (value) => helper__namespace.isDate(value), 'must be a valid date');
+// 带参数的验证装饰器
+const Equals = createParameterizedDecorator('Equals', (value, comparison) => value === comparison, 'must equal to $constraint1');
+const NotEquals = createParameterizedDecorator('NotEquals', (value, comparison) => value !== comparison, 'should not equal to $constraint1');
+const Contains = createParameterizedDecorator('Contains', (value, seed) => helper__namespace.isString(value) && value.includes(seed), 'must contain $constraint1');
+const IsIn = createParameterizedDecorator('IsIn', (value, possibleValues) => possibleValues.includes(value), 'must be one of the following values: $constraint1');
+const IsNotIn = createParameterizedDecorator('IsNotIn', (value, possibleValues) => !possibleValues.includes(value), 'should not be one of the following values: $constraint1');
+// 数值比较装饰器
+const Gt = createParameterizedDecorator('Gt', (value, min) => helper__namespace.toNumber(value) > min, 'must be greater than $constraint1');
+const Gte = createParameterizedDecorator('Gte', (value, min) => helper__namespace.toNumber(value) >= min, 'must be greater than or equal to $constraint1');
+const Lt = createParameterizedDecorator('Lt', (value, max) => helper__namespace.toNumber(value) < max, 'must be less than $constraint1');
+const Lte = createParameterizedDecorator('Lte', (value, max) => helper__namespace.toNumber(value) <= max, 'must be less than or equal to $constraint1');
+// 复杂验证装饰器（需要特殊处理）
 function IsEmail(options, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsEmail",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isEmail(value);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
+    return createParameterizedDecorator('IsEmail', (value) => classValidator.isEmail(value, options), 'must be a valid email')(validationOptions);
 }
-/**
- * Checks if the string is an IP (version 4 or 6). If given value is not a string, then it returns false.
- *
- * @export
- * @param {number} [version]
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
- */
 function IsIP(version, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsIP",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isIP(value, version);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
-    };
+    return createParameterizedDecorator('IsIP', (value) => classValidator.isIP(value, version), 'must be a valid IP address')(validationOptions);
+}
+function IsPhoneNumber(region, validationOptions) {
+    return createParameterizedDecorator('IsPhoneNumber', (value) => classValidator.isPhoneNumber(value, region), 'must be a valid phone number')(validationOptions);
+}
+function IsUrl(options, validationOptions) {
+    return createParameterizedDecorator('IsUrl', (value) => classValidator.isURL(value, options), 'must be a valid URL')(validationOptions);
+}
+function IsHash(algorithm, validationOptions) {
+    return createParameterizedDecorator('IsHash', (value) => classValidator.isHash(value, algorithm), 'must be a valid hash')(validationOptions);
 }
+// 基础工具装饰器（从原始decorator.ts移植）
 /**
- * Checks if the string is a valid phone number.
- *
- * @export
- * @param {string} {string} region 2 characters uppercase country code (e.g. DE, US, CH).
- * If users must enter the intl. prefix (e.g. +41), then you may pass "ZZ" or null as region.
- * See [google-libphonenumber, metadata.js:countryCodeToRegionCodeMap on github]
- * {@link https://github.com/ruimarinho/google-libphonenumber/blob/1e46138878cff479aafe2ce62175c6c49cb58720/src/metadata.js#L33}
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 标记属性为可导出
  */
-function IsPhoneNumber(region, validationOptions) {
+function Expose() {
     return function (object, propertyName) {
         setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsPhoneNumber",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isPhoneNumber(value, region);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
     };
 }
 /**
- * Checks if the string is an url.
- *
- * @export
- * @param {IsURLOptions} [options]
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * Expose的别名
  */
-function IsUrl(options, validationOptions) {
+function IsDefined() {
     return function (object, propertyName) {
         setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsUrl",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isURL(value, options);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
-                }
-            }
-        });
     };
 }
 /**
- * check if the string is a hash of type algorithm. Algorithm is one of ['md4', 'md5', 'sha1', 'sha256',
- * 'sha384', 'sha512', 'ripemd128', 'ripemd160', 'tiger128', 'tiger160', 'tiger192', 'crc32', 'crc32b']
- *
- * @export
- * @param {HashAlgorithm} algorithm
- * @param {ValidationOptions} [validationOptions]
- * @returns {PropertyDecorator}
+ * 参数验证装饰器
  */
-function IsHash(algorithm, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vIsHash",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return classValidator.isHash(value, algorithm);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter, ($property) must be is an ${algorithm} Hash string.`;
-                }
-            }
-        });
+function Valid(rule, options) {
+    return function (object, propertyName, parameterIndex) {
+        // 这里保持与原始实现一致
+        const existingRules = Reflect.getOwnMetadata("validate", object, propertyName) || {};
+        existingRules[parameterIndex] = { rule, options };
+        Reflect.defineMetadata("validate", existingRules, object, propertyName);
     };
 }
 /**
- * Use a custom function for validation
- * @param func
- * @param validationOptions
- * @returns
+ * 方法验证装饰器
+ * 自动验证方法参数中的 DTO 对象
  */
-function CheckFunc(func, validationOptions) {
-    return function (object, propertyName) {
-        setExpose(object, propertyName);
-        classValidator.registerDecorator({
-            name: "vCheckFunc",
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return func(value);
-                },
-                defaultMessage(_args) {
-                    return `invalid parameter ($property).`;
+function Validated() {
+    return function (object, propertyName, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            // 获取参数类型元数据
+            const paramTypes = Reflect.getMetadata('design:paramtypes', object, propertyName) || [];
+            // 验证每个参数
+            for (let i = 0; i < args.length; i++) {
+                const arg = args[i];
+                const paramType = paramTypes[i];
+                // 如果是类类型且不是基础类型，执行验证
+                if (paramType && typeof paramType === 'function' &&
+                    paramType !== String && paramType !== Number &&
+                    paramType !== Boolean && paramType !== Array &&
+                    paramType !== Object && paramType !== Date) {
+                    try {
+                        // 如果参数不是目标类型的实例，转换为实例
+                        let validationTarget = arg;
+                        if (!(arg instanceof paramType)) {
+                            validationTarget = Object.assign(new paramType(), arg);
+                        }
+                        const errors = await classValidator.validate(validationTarget);
+                        if (errors.length > 0) {
+                            throw createValidationErrors(errors.map(e => ({
+                                field: e.property,
+                                value: e.value,
+                                constraint: Object.keys(e.constraints || {})[0] || 'unknown',
+                                message: Object.values(e.constraints || {})[0] || 'Validation failed',
+                                context: e.constraints
+                            })));
+                        }
+                    }
+                    catch (error) {
+                        // 如果验证失败，重新抛出错误
+                        throw error;
+                    }
                 }
             }
-        });
+            // 执行原始方法
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
     };
 }
 
-exports.CheckFunc = CheckFunc;
 exports.ClassValidator = ClassValidator;
 exports.Contains = Contains;
 exports.ENABLE_VALIDATED = ENABLE_VALIDATED;
+exports.ERROR_MESSAGES = ERROR_MESSAGES;
 exports.Equals = Equals;
+exports.ErrorMessageFormatter = ErrorMessageFormatter;
 exports.Expose = Expose;
 exports.FunctionValidator = FunctionValidator;
 exports.Gt = Gt;
@@ -2762,7 +1550,7 @@ exports.IsPhoneNumber = IsPhoneNumber;
 exports.IsPlateNumber = IsPlateNumber;
 exports.IsUrl = IsUrl;
 exports.IsZipCode = IsZipCode;
-exports.Length = Length;
+exports.KoattyValidationError = KoattyValidationError;
 exports.Lt = Lt;
 exports.Lte = Lte;
 exports.NotEquals = NotEquals;
@@ -2772,7 +1560,23 @@ exports.PARAM_TYPE_KEY = PARAM_TYPE_KEY;
 exports.Valid = Valid;
 exports.ValidFuncs = ValidFuncs;
 exports.Validated = Validated;
+exports.cached = cached;
 exports.checkParamsType = checkParamsType;
+exports.clearAllCaches = clearAllCaches;
+exports.configureCaches = configureCaches;
 exports.convertDtoParamsType = convertDtoParamsType;
 exports.convertParamsType = convertParamsType;
+exports.createParameterizedDecorator = createParameterizedDecorator;
+exports.createSimpleDecorator = createSimpleDecorator;
+exports.createValidationDecorator = createValidationDecorator;
+exports.createValidationError = createValidationError;
+exports.createValidationErrors = createValidationErrors;
+exports.errorFormatter = errorFormatter;
+exports.getAllCacheStats = getAllCacheStats;
+exports.metadataCache = metadataCache;
+exports.performanceMonitor = performanceMonitor;
 exports.plainToClass = plainToClass;
+exports.regexCache = regexCache;
+exports.setValidationLanguage = setValidationLanguage;
+exports.validationCache = validationCache;
+exports.warmupCaches = warmupCaches;