umt 2.19.0 → 2.20.0

package/module/Validate/set/core.js

@@ -0,0 +1,47 @@
+/**
+ * Set validation core module
+ * Provides validation for `Set` instances. The validator can optionally
+ * delegate to a per-element validator, mirroring how `arrayOf()` validates
+ * each element of an array.
+ *
+ * The function is exported as `set_` because the top-level `Object` module
+ * already exposes a `set` runtime helper.
+ */
+/**
+ * Creates a Set validator. When a per-element validator is supplied, every
+ * element of the set must satisfy it; iteration short-circuits at the first
+ * failure and surfaces the failing message.
+ * @template IV - Validator for set elements
+ * @param {IV} [itemValidator] - Validator applied to every element
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for Set instances
+ */
+export const set_ = (itemValidator, message) => {
+    return (value) => {
+        if (!(value instanceof Set)) {
+            return {
+                validate: false,
+                message: message ?? "",
+                type: value,
+            };
+        }
+        if (itemValidator) {
+            for (const item of value) {
+                const result = itemValidator(item);
+                if (!result.validate) {
+                    return {
+                        validate: false,
+                        message: result.message,
+                        type: value,
+                    };
+                }
+            }
+        }
+        return {
+            validate: true,
+            message: "",
+            type: value,
+        };
+    };
+};
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/set/core.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAOlB,aAAkB,EAClB,OAAgB,EAChB,EAAE;IACF,OAAO,CAAC,KAAa,EAAkC,EAAE;QACvD,IAAI,CAAC,CAAC,KAAK,YAAY,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,KAAK;aACZ,CAAC;QACJ,CAAC;QACD,IAAI,aAAa,EAAE,CAAC;YAClB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,MAAM,GACV,aAID,CAAC,IAAI,CAAC,CAAC;gBACR,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;oBACrB,OAAO;wBACL,QAAQ,EAAE,KAAK;wBACf,OAAO,EAAE,MAAM,CAAC,OAAO;wBACvB,IAAI,EAAE,KAAK;qBACZ,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

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

package/module/Validate/set/index.js

@@ -0,0 +1,2 @@
+export * from "./core";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/set/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/module/Validate/templateLiteral/core.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Template literal validation core module
+ * Provides a validator that checks whether a string matches a template
+ * literal pattern composed of string fragments and primitive validators
+ * (string / number / boolean / bigint). The runtime check is performed by
+ * an auto-generated regular expression assembled from the parts, while the
+ * inferred type is the corresponding TypeScript template literal type.
+ */
+import type { ValidateType } from "../../Validate/type";
+type AnyValidator = (value?: any) => {
+    type: unknown;
+};
+/**
+ * Allowed parts of a template literal definition. Each element is either a
+ * string literal that must appear verbatim, or a primitive validator whose
+ * accepted shape is converted to a regex fragment at construction time.
+ */
+export type TemplateLiteralPart = string | AnyValidator;
+type ExtractValidatorTag<V> = V extends (value: never) => {
+    type: infer T;
+} ? T : never;
+type TagToTemplate<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "bigint" ? bigint : ValidateType<T>;
+type PartToTemplate<P> = P extends string ? P : TagToTemplate<ExtractValidatorTag<P>>;
+/**
+ * Builds the template literal type produced by joining `Parts`. Each part is
+ * mapped to either its literal string value or to the runtime type that the
+ * corresponding validator accepts.
+ */
+export type BuildTemplateLiteral<Parts extends readonly TemplateLiteralPart[]> = Parts extends readonly [
+    infer Head,
+    ...infer Tail extends readonly TemplateLiteralPart[]
+] ? `${Extract<PartToTemplate<Head>, string | number | bigint | boolean>}${BuildTemplateLiteral<Tail>}` : "";
+/**
+ * Return type produced by a `templateLiteral` validator. Preserves the
+ * literal template string type through the `type` field so consumers like
+ * `union()`, `intersection()`, and `SchemaToInterface` can recover it.
+ * @template T - The inferred template literal type
+ */
+export interface TemplateLiteralReturnType<T extends string> {
+    validate: boolean;
+    message: string;
+    type: T;
+}
+/**
+ * Creates a validator that checks whether a value matches a template literal
+ * pattern. Each part is either a string literal that must appear verbatim or
+ * a primitive validator (string / number / boolean / bigint) that contributes
+ * a regex fragment.
+ * @template Parts - Tuple describing the template parts
+ * @param {Parts} parts - Tuple of literal strings and primitive validators
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator function for template literal strings
+ */
+export declare const templateLiteral: <const Parts extends readonly TemplateLiteralPart[]>(parts: Parts, message?: string) => (value: BuildTemplateLiteral<Parts>) => TemplateLiteralReturnType<BuildTemplateLiteral<Parts>>;
+export {};

package/module/Validate/templateLiteral/core.js

@@ -0,0 +1,68 @@
+/**
+ * Template literal validation core module
+ * Provides a validator that checks whether a string matches a template
+ * literal pattern composed of string fragments and primitive validators
+ * (string / number / boolean / bigint). The runtime check is performed by
+ * an auto-generated regular expression assembled from the parts, while the
+ * inferred type is the corresponding TypeScript template literal type.
+ */
+const escapeRegex = (input) => input.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw `\$&`);
+const tagToPattern = (tag) => {
+    switch (tag) {
+        case "string": {
+            return ".*?";
+        }
+        case "number": {
+            return String.raw `-?(?:\d+\.\d+|\d+(?:\.\d*)?|\.\d+)`;
+        }
+        case "boolean": {
+            return "(?:true|false)";
+        }
+        case "bigint": {
+            return String.raw `-?\d+`;
+        }
+        default: {
+            return ".+?";
+        }
+    }
+};
+const detectValidatorTag = (validator) => {
+    const result = validator();
+    return result?.type;
+};
+/**
+ * Creates a validator that checks whether a value matches a template literal
+ * pattern. Each part is either a string literal that must appear verbatim or
+ * a primitive validator (string / number / boolean / bigint) that contributes
+ * a regex fragment.
+ * @template Parts - Tuple describing the template parts
+ * @param {Parts} parts - Tuple of literal strings and primitive validators
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator function for template literal strings
+ */
+export const templateLiteral = (parts, message) => {
+    let pattern = "^";
+    for (const part of parts) {
+        pattern +=
+            typeof part === "string"
+                ? escapeRegex(part)
+                : `(?:${tagToPattern(detectValidatorTag(part))})`;
+    }
+    pattern += "$";
+    const regex = new RegExp(pattern);
+    return (value) => {
+        if (typeof value !== "string" || !regex.test(value)) {
+            return {
+                validate: false,
+                message: message ?? "",
+                type: value,
+            };
+        }
+        return {
+            validate: true,
+            message: "",
+            type: value,
+        };
+    };
+};
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/templateLiteral/core.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyDH,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE,CAC5C,KAAK,CAAC,UAAU,CAAC,qBAAqB,EAAE,MAAM,CAAC,GAAG,CAAA,KAAK,CAAC,CAAC;AAE3D,MAAM,YAAY,GAAG,CAAC,GAAY,EAAU,EAAE;IAC5C,QAAQ,GAAG,EAAE,CAAC;QACZ,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,OAAO,KAAK,CAAC;QACf,CAAC;QACD,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,OAAO,MAAM,CAAC,GAAG,CAAA,oCAAoC,CAAC;QACxD,CAAC;QACD,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,OAAO,MAAM,CAAC,GAAG,CAAA,OAAO,CAAC;QAC3B,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,SAAuB,EAAW,EAAE;IAC9D,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;IAC3B,OAAO,MAAM,EAAE,IAAI,CAAC;AACtB,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAG7B,KAAY,EACZ,OAAgB,EAChB,EAAE;IACF,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,OAAO;YACL,OAAO,IAAI,KAAK,QAAQ;gBACtB,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC;gBACnB,CAAC,CAAC,MAAM,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;IACxD,CAAC;IACD,OAAO,IAAI,GAAG,CAAC;IACf,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;IAElC,OAAO,CACL,KAAkC,EACsB,EAAE;QAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACpD,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,KAAK;aACZ,CAAC;QACJ,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

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

package/module/Validate/templateLiteral/index.js

@@ -0,0 +1,2 @@
+export * from "./core";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/templateLiteral/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/module/Validate/type.d.ts

@@ -1,11 +1,12 @@
 export type _Types<T> = T extends string ? "string" : T extends number ? "number" : T extends boolean ? "boolean" : T;
 export type _Types2<T> = T extends undefined ? "undefined" : T extends null ? "null" : T;
+export type _Types3<T> = T extends bigint ? "bigint" : T;
 /**
  * Maps TypeScript types to their string literal representations
  * @template T - The type to map
- * @returns "string" for string, "number" for number, "boolean" for boolean, or the original type T otherwise
+ * @returns "string" for string, "number" for number, "boolean" for boolean, "bigint" for bigint, or the original type T otherwise
  */
-export type Types<T> = T extends string | number | boolean ? _Types<T> : T extends undefined | null ? _Types2<T> : T;
+export type Types<T> = T extends string | number | boolean ? _Types<T> : T extends undefined | null ? _Types2<T> : T extends bigint ? _Types3<T> : T;
 /**
  * Core validation result type including validation status, message, and type information
  * @template T - The type being validated
@@ -31,12 +32,13 @@ export interface ValidateReturnType<T> {
 export type ValidateFunctionType<T> = (value: T) => boolean;
 export type _ValidateType<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T;
 export type _ValidateType2<T> = T extends "undefined" ? undefined : T extends "null" ? null : T;
+export type _ValidateType3<T> = T extends "bigint" ? bigint : T extends "any" ? any : T extends "unknown" ? unknown : T extends "never" ? never : T;
 /**
  * Maps string literal type names back to their TypeScript types
- * @template T - The string literal type name ("string", "number", "boolean")
- * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
+ * @template T - The string literal type name ("string", "number", "boolean", "bigint", "undefined", "null", "any", "unknown", "never")
+ * @returns The corresponding TypeScript type or the original type T when no tag matches
  */
-export type ValidateType<T> = T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T;
+export type ValidateType<T> = T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T extends "bigint" | "any" | "unknown" | "never" ? _ValidateType3<T> : T;
 export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ValidateType<ReturnType<T>["type"]>;
 export type OptionalKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? K : never;

package/module/Validate/unknown/core.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unknown validation core module
+ * Provides a validator that accepts any value but exposes it as `unknown`
+ * to keep callers honest about narrowing before use.
+ */
+/**
+ * Return type produced by an `unknown` validator. Exposes the literal
+ * `"unknown"` tag through the `type` field so `ValidateType<"unknown">` can
+ * map it back to the `unknown` runtime type when consumed by downstream
+ * helpers.
+ */
+export interface UnknownReturnType {
+    validate: boolean;
+    message: string;
+    type: "unknown";
+}
+/**
+ * Creates a validator that accepts any value but typed as unknown
+ * @returns {Function} - Validator that always succeeds
+ */
+export declare const unknown: () => ((value: unknown) => UnknownReturnType);

package/module/Validate/unknown/core.js

@@ -0,0 +1,16 @@
+/**
+ * Unknown validation core module
+ * Provides a validator that accepts any value but exposes it as `unknown`
+ * to keep callers honest about narrowing before use.
+ */
+const unknownValidator = (_value) => ({
+    validate: true,
+    message: "",
+    type: "unknown",
+});
+/**
+ * Creates a validator that accepts any value but typed as unknown
+ * @returns {Function} - Validator that always succeeds
+ */
+export const unknown = () => unknownValidator;
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/unknown/core.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAcH,MAAM,gBAAgB,GAAG,CAAC,MAAe,EAAqB,EAAE,CAAC,CAAC;IAChE,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,SAAS;CAChB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAA4C,EAAE,CACnE,gBAAgB,CAAC"}

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

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

package/module/Validate/unknown/index.js

@@ -0,0 +1,2 @@
+export * from "./core";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/unknown/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * Any validation core module
+ * Provides a validator that accepts any value, useful when a position in a
+ * schema needs to remain wide open while still participating in `object()`,
+ * `union()`, `intersection()`, and other compositional helpers.
+ */
+/**
+ * Return type produced by an `any` validator. Exposes the literal `"any"`
+ * tag through the `type` field so `ValidateType<"any">` can map it back to
+ * the `any` runtime type when consumed by downstream helpers.
+ */
+export interface AnyReturnType {
+    validate: boolean;
+    message: string;
+    type: "any";
+}
+/**
+ * Creates a validator that accepts any value
+ * @returns {Function} - Validator that always succeeds
+ */
+export declare const any: () => ((value: any) => AnyReturnType);

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.any = void 0;
+/**
+ * Any validation core module
+ * Provides a validator that accepts any value, useful when a position in a
+ * schema needs to remain wide open while still participating in `object()`,
+ * `union()`, `intersection()`, and other compositional helpers.
+ */
+
+/**
+ * Return type produced by an `any` validator. Exposes the literal `"any"`
+ * tag through the `type` field so `ValidateType<"any">` can map it back to
+ * the `any` runtime type when consumed by downstream helpers.
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: signature mirrors the return type
+var anyValidator = function anyValidator(_value) {
+  return {
+    validate: true,
+    message: "",
+    type: "any"
+  };
+};
+
+/**
+ * Creates a validator that accepts any value
+ * @returns {Function} - Validator that always succeeds
+ */
+// biome-ignore lint/suspicious/noExplicitAny: any() must accept and infer any value
+var any = exports.any = function any() {
+  return anyValidator;
+};

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

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

package/module/es5/Validate/any/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/array/arrayOf.d.ts

@@ -2,8 +2,13 @@ import type { ValidateCoreReturnType } from "../../Validate/type";
 /**
  * Creates an array validator that validates every element with a single validator
  * @template T - Element type validated by the wrapped validator
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
  * @param {Function} validator - Validator applied to each element (e.g. an object validator)
  * @param {string} [message] - Custom error message for array type validation
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator
  */
-export declare const arrayOf: <T>(validator: (value: T) => ValidateCoreReturnType<T>, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;
+export declare const arrayOf: <T, R extends {
+    type: unknown;
+    message: string;
+    validate: boolean;
+}>(validator: (value: T) => R, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;

package/module/es5/Validate/array/arrayOf.js

@@ -11,6 +11,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 /**
  * Creates an array validator that validates every element with a single validator
  * @template T - Element type validated by the wrapped validator
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
  * @param {Function} validator - Validator applied to each element (e.g. an object validator)
  * @param {string} [message] - Custom error message for array type validation
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator

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

@@ -0,0 +1,24 @@
+/**
+ * BigInt validation core module
+ * Provides the base validation functionality for bigint values
+ */
+import type { ValidateReturnType } from "../../Validate/type";
+/**
+ * Return type produced by a `bigint` validator. Structurally compatible with
+ * `ValidateCoreReturnType<bigint>`, but exposes the literal `"bigint"` tag
+ * through the `type` field so `ValidateType<"bigint">` can map it back to the
+ * `bigint` runtime type when consumed by `object()`, `union()`, and friends.
+ */
+export interface BigIntReturnType {
+    validate: boolean;
+    message: string;
+    type: "bigint";
+}
+/**
+ * Creates a bigint validator with optional validation rules
+ * @template T - Array of validation rules for bigints
+ * @param {T} [option] - Array of validation functions to apply
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function that checks if the value is a bigint and applies validation rules
+ */
+export declare const bigint: <T extends ValidateReturnType<bigint>[]>(option?: T, message?: string) => (value: bigint) => BigIntReturnType;

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

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bigint = void 0;
+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; }
+/**
+ * BigInt validation core module
+ * Provides the base validation functionality for bigint values
+ */
+
+/**
+ * Return type produced by a `bigint` validator. Structurally compatible with
+ * `ValidateCoreReturnType<bigint>`, but exposes the literal `"bigint"` tag
+ * through the `type` field so `ValidateType<"bigint">` can map it back to the
+ * `bigint` runtime type when consumed by `object()`, `union()`, and friends.
+ */
+
+/**
+ * Creates a bigint validator with optional validation rules
+ * @template T - Array of validation rules for bigints
+ * @param {T} [option] - Array of validation functions to apply
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function that checks if the value is a bigint and applies validation rules
+ */
+var bigint = exports.bigint = function bigint() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var message = arguments.length > 1 ? arguments[1] : undefined;
+  return function (value) {
+    if (typeof value !== "bigint") {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: "bigint"
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(option),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var rule = _step.value;
+        if (!rule.validate(value)) {
+          var _rule$message;
+          return {
+            validate: false,
+            message: (_rule$message = rule.message) !== null && _rule$message !== void 0 ? _rule$message : "",
+            type: "bigint"
+          };
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return {
+      validate: true,
+      message: "",
+      type: "bigint"
+    };
+  };
+};

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

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

package/module/es5/Validate/bigint/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/date/core.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Date validation core module
+ * Provides the base validation functionality for Date instances
+ */
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Creates a Date validator. The validator checks both that the value is an
+ * instance of Date and that it represents a valid moment in time (i.e. its
+ * underlying timestamp is not NaN), so values created from invalid inputs
+ * such as `new Date("not-a-date")` are rejected.
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function that checks if the value is a Date instance
+ */
+export declare const date: (message?: string) => (value: Date) => ValidateCoreReturnType<Date>;

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.date = void 0;
+/**
+ * Date validation core module
+ * Provides the base validation functionality for Date instances
+ */
+
+/**
+ * Creates a Date validator. The validator checks both that the value is an
+ * instance of Date and that it represents a valid moment in time (i.e. its
+ * underlying timestamp is not NaN), so values created from invalid inputs
+ * such as `new Date("not-a-date")` are rejected.
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function that checks if the value is a Date instance
+ */
+var date = exports.date = function date(message) {
+  return function (value) {
+    if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

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

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

package/module/es5/Validate/date/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/file/core.d.ts

@@ -0,0 +1,13 @@
+/**
+ * File validation core module
+ * Provides validation for File / Blob instances. Falls back to `Blob` when
+ * the global `File` constructor is unavailable.
+ */
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Creates a validator that checks whether a value is a `File` (or `Blob` in
+ * runtimes where `File` is not available)
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for File / Blob instances
+ */
+export declare const file: (message?: string) => (value: File) => ValidateCoreReturnType<File>;

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.file = void 0;
+/**
+ * File validation core module
+ * Provides validation for File / Blob instances. Falls back to `Blob` when
+ * the global `File` constructor is unavailable.
+ */
+
+var hasFileConstructor = typeof File !== "undefined";
+var hasBlobConstructor = typeof Blob !== "undefined";
+
+/**
+ * Creates a validator that checks whether a value is a `File` (or `Blob` in
+ * runtimes where `File` is not available)
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for File / Blob instances
+ */
+var file = exports.file = function file(message) {
+  return function (value) {
+    var isFile = hasFileConstructor && value instanceof File;
+    var isBlob = hasBlobConstructor && value instanceof Blob;
+    if (!(isFile || isBlob)) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

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

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