umt 2.19.0 → 2.20.0

package/module/es5/Validate/file/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});

package/module/es5/Validate/function/core.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Function validation core module
+ * Provides a validator for function values along with an `implement()`
+ * helper that wraps a concrete function with runtime validation of its
+ * inputs and output.
+ *
+ * The runtime validator only enforces that the value is a function, since
+ * argument and return-value contracts can only be checked when the function
+ * is actually invoked. Use `.implement()` (or call the validator's
+ * `implement` property directly) to create a wrapped function that asserts
+ * the schema on every call.
+ */
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type AnyValidator = (value: any) => ValidateCoreReturnType<unknown>;
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
+type InferInputs<Inputs> = Inputs extends readonly AnyValidator[] ? {
+    [K in keyof Inputs]: ExtractValidatedType<Inputs[K]>;
+} : any[];
+type InferOutput<Output> = Output extends AnyValidator ? ExtractValidatedType<Output> : any;
+/**
+ * Function schema definition. `input` describes positional parameters and
+ * `output` describes the return type. Both are optional; when omitted the
+ * validator only enforces that the value is callable.
+ */
+export interface FunctionSchema {
+    input?: readonly AnyValidator[];
+    output?: AnyValidator;
+}
+type ExtractInput<S> = S extends {
+    input: infer I;
+} ? I : undefined;
+type ExtractOutput<S> = S extends {
+    output: infer O;
+} ? O : undefined;
+/**
+ * Inferred function signature from a `FunctionSchema`. Used by callers via
+ * `SchemaToInterface` and as the return type of `implement()`.
+ * @template Inputs - Tuple of validators describing positional parameters
+ * @template Output - Validator describing the return value
+ */
+export type InferFunction<Inputs, Output> = (...arguments_: InferInputs<Inputs>) => InferOutput<Output>;
+/**
+ * Validator return type. Carries the inferred function signature through
+ * the `type` field so `SchemaToInterface` can recover it.
+ * @template Inputs - Tuple of validators describing positional parameters
+ * @template Output - Validator describing the return value
+ */
+export interface FunctionReturnType<Inputs, Output> {
+    validate: boolean;
+    message: string;
+    type: InferFunction<Inputs, Output>;
+}
+/**
+ * Validator value enriched with an `implement()` method that returns a
+ * runtime-checked wrapper of a concrete function matching the schema.
+ * @template Inputs - Tuple of validators describing positional parameters
+ * @template Output - Validator describing the return value
+ */
+export interface FunctionValidator<Inputs, Output> {
+    (value: InferFunction<Inputs, Output>): FunctionReturnType<Inputs, Output>;
+    implement: (function__: InferFunction<Inputs, Output>) => InferFunction<Inputs, Output>;
+}
+/**
+ * Creates a function validator. When invoked the validator only checks that
+ * the value is callable; use `.implement()` on the returned validator to
+ * obtain a runtime-checked wrapper that asserts the schema for each call.
+ * @template S - Function schema type, captured for input/output inference
+ * @param {S} [schema] - Function schema definition
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {FunctionValidator} - Validator augmented with `implement()`
+ */
+export declare const function_: <const S extends FunctionSchema = FunctionSchema>(schema?: S, message?: string) => FunctionValidator<ExtractInput<S>, ExtractOutput<S>>;
+export {};

package/module/es5/Validate/function/core.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.function_ = void 0;
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Function validation core module
+ * Provides a validator for function values along with an `implement()`
+ * helper that wraps a concrete function with runtime validation of its
+ * inputs and output.
+ *
+ * The runtime validator only enforces that the value is a function, since
+ * argument and return-value contracts can only be checked when the function
+ * is actually invoked. Use `.implement()` (or call the validator's
+ * `implement` property directly) to create a wrapped function that asserts
+ * the schema on every call.
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: validator signatures vary
+
+/**
+ * Function schema definition. `input` describes positional parameters and
+ * `output` describes the return type. Both are optional; when omitted the
+ * validator only enforces that the value is callable.
+ */
+
+/**
+ * Inferred function signature from a `FunctionSchema`. Used by callers via
+ * `SchemaToInterface` and as the return type of `implement()`.
+ * @template Inputs - Tuple of validators describing positional parameters
+ * @template Output - Validator describing the return value
+ */
+
+/**
+ * Validator return type. Carries the inferred function signature through
+ * the `type` field so `SchemaToInterface` can recover it.
+ * @template Inputs - Tuple of validators describing positional parameters
+ * @template Output - Validator describing the return value
+ */
+
+/**
+ * Validator value enriched with an `implement()` method that returns a
+ * runtime-checked wrapper of a concrete function matching the schema.
+ * @template Inputs - Tuple of validators describing positional parameters
+ * @template Output - Validator describing the return value
+ */
+
+/**
+ * Creates a function validator. When invoked the validator only checks that
+ * the value is callable; use `.implement()` on the returned validator to
+ * obtain a runtime-checked wrapper that asserts the schema for each call.
+ * @template S - Function schema type, captured for input/output inference
+ * @param {S} [schema] - Function schema definition
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {FunctionValidator} - Validator augmented with `implement()`
+ */
+var function_ = exports.function_ = function function_(schema, message) {
+  var inputs = schema === null || schema === void 0 ? void 0 : schema.input;
+  var output = schema === null || schema === void 0 ? void 0 : schema.output;
+  var validator = function validator(value) {
+    if (typeof value !== "function") {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+  validator.implement = function (function__) {
+    if (typeof function__ !== "function") {
+      throw new TypeError(message !== null && message !== void 0 ? message : "value is not a function");
+    }
+    var wrapped = function wrapped() {
+      for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+        arguments_[_key] = arguments[_key];
+      }
+      if (inputs) {
+        var _iterator = _createForOfIteratorHelper(inputs.entries()),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _slicedToArray(_step.value, 2),
+              index = _step$value[0],
+              inputValidator = _step$value[1];
+            var result = inputValidator(arguments_[index]);
+            if (!result.validate) {
+              throw new TypeError(result.message || "function input at index ".concat(index, " failed validation"));
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      var returnValue = function__.apply(void 0, _toConsumableArray(arguments_));
+      if (output) {
+        var _result = output(returnValue);
+        if (!_result.validate) {
+          throw new TypeError(_result.message || "function output failed validation");
+        }
+      }
+      return returnValue;
+    };
+    return wrapped;
+  };
+  return validator;
+};

package/module/es5/Validate/function/index.d.ts

@@ -0,0 +1 @@
+export * from "./core";

package/module/es5/Validate/function/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});

package/module/es5/Validate/index.d.ts

@@ -1,9 +1,20 @@
+export * from "./any";
 export * from "./array";
+export * from "./bigint";
 export * from "./boolean";
+export * from "./date";
+export * from "./file";
+export * from "./function";
+export * from "./instanceof";
+export * from "./map";
+export * from "./never";
 export * from "./number";
 export * from "./object";
+export * from "./set";
 export * from "./string";
+export * from "./templateLiteral";
 export * from "./type";
+export * from "./unknown";
 export * from "./isDeepEqual";
 export * from "./isArray";
 export * from "./isBrowser";

package/module/es5/Validate/index.js

@@ -3,6 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _any = require("./any");
+Object.keys(_any).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _any[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _any[key];
+    }
+  });
+});
 var _array = require("./array");
 Object.keys(_array).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -14,6 +25,17 @@ Object.keys(_array).forEach(function (key) {
     }
   });
 });
+var _bigint = require("./bigint");
+Object.keys(_bigint).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bigint[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _bigint[key];
+    }
+  });
+});
 var _boolean = require("./boolean");
 Object.keys(_boolean).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -25,6 +47,72 @@ Object.keys(_boolean).forEach(function (key) {
     }
   });
 });
+var _date = require("./date");
+Object.keys(_date).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _date[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _date[key];
+    }
+  });
+});
+var _file = require("./file");
+Object.keys(_file).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _file[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _file[key];
+    }
+  });
+});
+var _function = require("./function");
+Object.keys(_function).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _function[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _function[key];
+    }
+  });
+});
+var _instanceof = require("./instanceof");
+Object.keys(_instanceof).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _instanceof[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _instanceof[key];
+    }
+  });
+});
+var _map = require("./map");
+Object.keys(_map).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _map[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _map[key];
+    }
+  });
+});
+var _never = require("./never");
+Object.keys(_never).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _never[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _never[key];
+    }
+  });
+});
 var _number = require("./number");
 Object.keys(_number).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -47,6 +135,17 @@ Object.keys(_object).forEach(function (key) {
     }
   });
 });
+var _set = require("./set");
+Object.keys(_set).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _set[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _set[key];
+    }
+  });
+});
 var _string = require("./string");
 Object.keys(_string).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -58,6 +157,17 @@ Object.keys(_string).forEach(function (key) {
     }
   });
 });
+var _templateLiteral = require("./templateLiteral");
+Object.keys(_templateLiteral).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _templateLiteral[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _templateLiteral[key];
+    }
+  });
+});
 var _type = require("./type");
 Object.keys(_type).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -69,6 +179,17 @@ Object.keys(_type).forEach(function (key) {
     }
   });
 });
+var _unknown = require("./unknown");
+Object.keys(_unknown).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _unknown[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _unknown[key];
+    }
+  });
+});
 var _isDeepEqual = require("./isDeepEqual");
 Object.keys(_isDeepEqual).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/instanceof/core.d.ts

@@ -0,0 +1,19 @@
+/**
+ * instanceof validation core module
+ * Provides a validator that checks whether a value is an instance of a
+ * specific constructor, including subclasses. The validator is exported as
+ * `instanceof_` because `instanceof` is a reserved keyword in JavaScript.
+ */
+import type { ValidateCoreReturnType } from "../../Validate/type";
+type Constructor<T> = new (...arguments_: any[]) => T;
+/**
+ * Creates a validator that checks whether a value is an instance of the given
+ * constructor. Subclasses of the constructor satisfy the validator, matching
+ * native `instanceof` semantics.
+ * @template T - The instance type produced by the constructor
+ * @param {Constructor<T>} classConstructor - Constructor whose instances are accepted
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator function for instances of the constructor
+ */
+export declare const instanceof_: <T>(classConstructor: Constructor<T>, message?: string) => (value: T) => ValidateCoreReturnType<T>;
+export {};

package/module/es5/Validate/instanceof/core.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instanceof_ = void 0;
+/**
+ * instanceof validation core module
+ * Provides a validator that checks whether a value is an instance of a
+ * specific constructor, including subclasses. The validator is exported as
+ * `instanceof_` because `instanceof` is a reserved keyword in JavaScript.
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: a constructor signature must accept any tuple
+
+/**
+ * Creates a validator that checks whether a value is an instance of the given
+ * constructor. Subclasses of the constructor satisfy the validator, matching
+ * native `instanceof` semantics.
+ * @template T - The instance type produced by the constructor
+ * @param {Constructor<T>} classConstructor - Constructor whose instances are accepted
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator function for instances of the constructor
+ */
+var instanceof_ = exports.instanceof_ = function instanceof_(classConstructor, message) {
+  return function (value) {
+    if (!(value instanceof classConstructor)) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

package/module/es5/Validate/instanceof/index.d.ts

@@ -0,0 +1 @@
+export * from "./core";

package/module/es5/Validate/instanceof/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});

package/module/es5/Validate/map/core.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Map validation core module
+ * Provides validation for `Map` instances. The validator can optionally
+ * delegate to per-entry validators for keys and values, mirroring how
+ * `arrayOf()` validates each element of an array.
+ */
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
+/**
+ * Creates a Map validator. The validator can optionally accept per-entry key
+ * and value validators that are applied to every entry of the map. When the
+ * value-side validator is provided, the entry validators short-circuit on the
+ * first failure and surface the failing message, mirroring `arrayOf()`.
+ * @template KV - Validator for the map key
+ * @template VV - Validator for the map value
+ * @param {KV} [keyValidator] - Validator applied to every key
+ * @param {VV} [valueValidator] - Validator applied to every value
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for Map instances
+ */
+export declare const map: <KV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, VV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, K = ExtractValidatedType<KV>, V = ExtractValidatedType<VV>>(keyValidator?: KV, valueValidator?: VV, message?: string) => (value: Map<K, V>) => ValidateCoreReturnType<Map<K, V>>;
+export {};

package/module/es5/Validate/map/core.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.map = void 0;
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Map validation core module
+ * Provides validation for `Map` instances. The validator can optionally
+ * delegate to per-entry validators for keys and values, mirroring how
+ * `arrayOf()` validates each element of an array.
+ */
+
+/**
+ * Creates a Map validator. The validator can optionally accept per-entry key
+ * and value validators that are applied to every entry of the map. When the
+ * value-side validator is provided, the entry validators short-circuit on the
+ * first failure and surface the failing message, mirroring `arrayOf()`.
+ * @template KV - Validator for the map key
+ * @template VV - Validator for the map value
+ * @param {KV} [keyValidator] - Validator applied to every key
+ * @param {VV} [valueValidator] - Validator applied to every value
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for Map instances
+ */
+var map = exports.map = function map(keyValidator, valueValidator, message) {
+  return function (value) {
+    if (!(value instanceof Map)) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(value),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          entryKey = _step$value[0],
+          entryValue = _step$value[1];
+        if (keyValidator) {
+          var keyResult = keyValidator(entryKey);
+          if (!keyResult.validate) {
+            return {
+              validate: false,
+              message: keyResult.message,
+              type: value
+            };
+          }
+        }
+        if (valueValidator) {
+          var valueResult = valueValidator(entryValue);
+          if (!valueResult.validate) {
+            return {
+              validate: false,
+              message: valueResult.message,
+              type: value
+            };
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

package/module/es5/Validate/map/index.d.ts

@@ -0,0 +1 @@
+export * from "./core";

package/module/es5/Validate/map/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});

package/module/es5/Validate/never/core.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Never validation core module
+ * Provides a validator that fails for every input, useful for marking
+ * positions in a schema that must never be filled (for example, exhaustive
+ * union members that should be unreachable at the type level).
+ */
+/**
+ * Return type produced by a `never` validator. Exposes the literal `"never"`
+ * tag through the `type` field so `ValidateType<"never">` can map it back to
+ * the `never` runtime type when consumed by downstream helpers.
+ */
+export interface NeverReturnType {
+    validate: boolean;
+    message: string;
+    type: "never";
+}
+/**
+ * Creates a validator that always fails
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator that always returns a failing result
+ */
+export declare const never: (message?: string) => ((value: any) => NeverReturnType);