umt 3.0.0 → 3.2.0

package/module/es5/Validate/object/optional.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.optional = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Optional validator augmented with a reference to the wrapped validator,
  * used by `required()` to unwrap optional layers when rebuilding a shape
@@ -31,5 +32,5 @@ var optional = exports.optional = function optional(validator) {
   };
   optionalValidator.inner = validator;
   optionalValidator.isOptional = true;
-  return optionalValidator;
+  return (0, _standardSchema.attachStandard)(optionalValidator);
 };

package/module/es5/Validate/object/partial.d.ts

@@ -6,7 +6,7 @@
  */
 import { type ObjectShape, type ObjectValidator } from "./core";
 import { type OptionalValidator } from "./optional";
-type PartialShape<T extends ObjectShape> = {
+export type PartialShape<T extends ObjectShape> = {
     [K in keyof T]: OptionalValidator<Parameters<T[K]>[0], ReturnType<T[K]> extends {
         type: unknown;
         message: string;
@@ -22,4 +22,3 @@ type PartialShape<T extends ObjectShape> = {
  * @returns {ObjectValidator<PartialShape<T>>} - New validator where every key accepts undefined
  */
 export declare const partial: <T extends ObjectShape>(validator: ObjectValidator<T>, message?: string) => ObjectValidator<PartialShape<T>>;
-export {};

package/module/es5/Validate/object/required.d.ts

@@ -6,8 +6,8 @@
  */
 import { type ObjectShape, type ObjectValidator } from "./core";
 import type { OptionalValidator } from "./optional";
-type UnwrapOptional<V> = V extends OptionalValidator<infer Inner, infer R> ? (value: Inner) => R : V;
-type RequiredShape<T extends ObjectShape> = {
+export type UnwrapOptional<V> = V extends OptionalValidator<infer Inner, infer R> ? (value: Inner) => R : V;
+export type RequiredShape<T extends ObjectShape> = {
     [K in keyof T]: UnwrapOptional<T[K]> extends ObjectShape[string] ? UnwrapOptional<T[K]> : T[K];
 };
 /**
@@ -19,4 +19,3 @@ type RequiredShape<T extends ObjectShape> = {
  * @returns {ObjectValidator<RequiredShape<T>>} - New validator where every optional layer is removed
  */
 export declare const required: <T extends ObjectShape>(validator: ObjectValidator<T>, message?: string) => ObjectValidator<RequiredShape<T>>;
-export {};

package/module/es5/Validate/object/union.d.ts

@@ -1,5 +1,6 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => {
+export type UnionExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
 /**
@@ -7,5 +8,4 @@ type ExtractValidatedType<V> = V extends (value: never) => {
  * @param validators - Validator functions to compose as a union (logical OR)
  * @returns {Function} - Validator that checks if the value matches any of the validators
  */
-export declare const union: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: ExtractValidatedType<Vs[number]>) => ValidateCoreReturnType<ExtractValidatedType<Vs[number]>>;
-export {};
+export declare const union: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => ((value: UnionExtractValidatedType<Vs[number]>) => ValidateCoreReturnType<UnionExtractValidatedType<Vs[number]>>) & StandardSchemaV1<UnionExtractValidatedType<Vs[number]>, UnionExtractValidatedType<Vs[number]>>;

package/module/es5/Validate/object/union.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.union = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 // Extract the validated value type by reading the validator's `type` field
 // (and applying `ValidateType` to map type tags like "string" back to the
 // runtime type). Reading the field directly lets validators that expose the
@@ -19,7 +20,7 @@ var union = exports.union = function union() {
   for (var _len = arguments.length, validators = new Array(_len), _key = 0; _key < _len; _key++) {
     validators[_key] = arguments[_key];
   }
-  return function (value) {
+  var unionValidator = function unionValidator(value) {
     var lastMessage = "";
     for (var _i = 0, _validators = validators; _i < _validators.length; _i++) {
       var validator = _validators[_i];
@@ -39,4 +40,5 @@ var union = exports.union = function union() {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(unionValidator);
 };

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

@@ -7,8 +7,9 @@
  * The function is exported as `set_` because the top-level `Object` module
  * already exposes a `set` runtime helper.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => {
+export type SetExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
 /**
@@ -20,5 +21,4 @@ type ExtractValidatedType<V> = V extends (value: never) => {
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function for Set instances
  */
-export declare const set_: <IV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, T = ExtractValidatedType<IV>>(itemValidator?: IV, message?: string) => (value: Set<T>) => ValidateCoreReturnType<Set<T>>;
-export {};
+export declare const set_: <IV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, T = SetExtractValidatedType<IV>>(itemValidator?: IV, message?: string) => ((value: Set<T>) => ValidateCoreReturnType<Set<T>>) & StandardSchemaV1<Set<T>, Set<T>>;

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

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.set_ = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 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 _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; } /**
  * Set validation core module
  * Provides validation for `Set` instances. The validator can optionally
  * delegate to a per-element validator, mirroring how `arrayOf()` validates
@@ -16,7 +16,6 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * 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
@@ -27,7 +26,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * @returns {Function} - Validator function for Set instances
  */
 var set_ = exports.set_ = function set_(itemValidator, message) {
-  return function (value) {
+  var setValidator = function setValidator(value) {
     if (!(value instanceof Set)) {
       return {
         validate: false,
@@ -62,4 +61,5 @@ var set_ = exports.set_ = function set_(itemValidator, message) {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(setValidator);
 };

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

@@ -0,0 +1,93 @@
+/**
+ * Standard Schema V1 integration
+ *
+ * Defines the public Standard Schema V1 surface (https://standardschema.dev)
+ * and exposes the `attachStandard()` helper used by every UMT validator
+ * factory to advertise itself as a Standard Schema V1 implementation. The
+ * `~standard` property added by `attachStandard()` lets external tools
+ * (Zod-, Valibot-, ArkType-style ecosystems) consume UMT validators without
+ * adapters.
+ *
+ * Biome's `noNamespace` lint rule forbids TypeScript namespaces, so the spec
+ * is mirrored with flat interface/type names that remain structurally
+ * compatible with the official `StandardSchemaV1` interface published by
+ * `@standard-schema/spec`.
+ */
+/** The Standard Schema V1 interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1Properties<Input, Output>;
+}
+/** The Standard Schema V1 properties interface. */
+export interface StandardSchemaV1Properties<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
+}
+/** The result type produced by `Props.validate`. */
+export type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+/** The result interface when validation succeeds. */
+export interface StandardSchemaV1SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+}
+/** The result interface when validation fails. */
+export interface StandardSchemaV1FailureResult {
+    readonly issues: readonly StandardSchemaV1Issue[];
+}
+/** The issue interface returned on failure. */
+export interface StandardSchemaV1Issue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | StandardSchemaV1PathSegment)[] | undefined;
+}
+/** The path segment interface for nested issues. */
+export interface StandardSchemaV1PathSegment {
+    readonly key: PropertyKey;
+}
+/** The Standard Schema V1 types interface. */
+export interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+}
+/** Infers the input type of a Standard Schema V1 implementation. */
+export type StandardSchemaV1InferInput<Schema extends StandardSchemaV1<any, any>> = NonNullable<Schema["~standard"]["types"]>["input"];
+/** Infers the output type of a Standard Schema V1 implementation. */
+export type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1<any, any>> = NonNullable<Schema["~standard"]["types"]>["output"];
+/**
+ * Vendor identifier used by all UMT validators when advertising Standard
+ * Schema V1 compatibility. External tools may key off this value to attach
+ * UMT-specific behavior.
+ */
+export declare const STANDARD_SCHEMA_VENDOR = "umt";
+/** Minimal shape of UMT validator results consumed by `attachStandard`. */
+export interface UmtValidatorResult {
+    validate: boolean;
+    message: string;
+    type: unknown;
+}
+/**
+ * Attaches a Standard Schema V1 `~standard` property to a UMT validator
+ * function in place. The validator's existing call signature, attached
+ * helpers (such as `shape` on `object()` or `implement` on `function_()`),
+ * and return type are preserved untouched; only the `~standard` property is
+ * added.
+ *
+ * Validation is delegated to the wrapped validator. On success the input
+ * value is returned through the Standard Schema `value` field; on failure a
+ * single issue carrying the validator's message is emitted. UMT validators
+ * never transform their input, so `Input` and `Output` default to the same
+ * type.
+ *
+ * @template Input - The input type advertised through `~standard.types`
+ * @template Output - The output type advertised through `~standard.types`
+ * @template F - The validator function being augmented
+ * @param {F} validator - The validator function to augment
+ * @returns {F & StandardSchemaV1<Input, Output>} The same function with `~standard` attached
+ */
+export declare const attachStandard: <Input, Output = Input, F extends (...arguments_: any[]) => UmtValidatorResult = (...arguments_: any[]) => UmtValidatorResult>(validator: F) => F & StandardSchemaV1<Input, Output>;

package/module/es5/Validate/standardSchema.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attachStandard = exports.STANDARD_SCHEMA_VENDOR = void 0;
+/**
+ * Standard Schema V1 integration
+ *
+ * Defines the public Standard Schema V1 surface (https://standardschema.dev)
+ * and exposes the `attachStandard()` helper used by every UMT validator
+ * factory to advertise itself as a Standard Schema V1 implementation. The
+ * `~standard` property added by `attachStandard()` lets external tools
+ * (Zod-, Valibot-, ArkType-style ecosystems) consume UMT validators without
+ * adapters.
+ *
+ * Biome's `noNamespace` lint rule forbids TypeScript namespaces, so the spec
+ * is mirrored with flat interface/type names that remain structurally
+ * compatible with the official `StandardSchemaV1` interface published by
+ * `@standard-schema/spec`.
+ */
+
+/** The Standard Schema V1 interface. */
+
+/** The Standard Schema V1 properties interface. */
+
+/** The result type produced by `Props.validate`. */
+
+/** The result interface when validation succeeds. */
+
+/** The result interface when validation fails. */
+
+/** The issue interface returned on failure. */
+
+/** The path segment interface for nested issues. */
+
+/** The Standard Schema V1 types interface. */
+
+/** Infers the input type of a Standard Schema V1 implementation. */
+
+/** Infers the output type of a Standard Schema V1 implementation. */
+
+/**
+ * Vendor identifier used by all UMT validators when advertising Standard
+ * Schema V1 compatibility. External tools may key off this value to attach
+ * UMT-specific behavior.
+ */
+var STANDARD_SCHEMA_VENDOR = exports.STANDARD_SCHEMA_VENDOR = "umt";
+
+/** Minimal shape of UMT validator results consumed by `attachStandard`. */
+
+/**
+ * Attaches a Standard Schema V1 `~standard` property to a UMT validator
+ * function in place. The validator's existing call signature, attached
+ * helpers (such as `shape` on `object()` or `implement` on `function_()`),
+ * and return type are preserved untouched; only the `~standard` property is
+ * added.
+ *
+ * Validation is delegated to the wrapped validator. On success the input
+ * value is returned through the Standard Schema `value` field; on failure a
+ * single issue carrying the validator's message is emitted. UMT validators
+ * never transform their input, so `Input` and `Output` default to the same
+ * type.
+ *
+ * @template Input - The input type advertised through `~standard.types`
+ * @template Output - The output type advertised through `~standard.types`
+ * @template F - The validator function being augmented
+ * @param {F} validator - The validator function to augment
+ * @returns {F & StandardSchemaV1<Input, Output>} The same function with `~standard` attached
+ */
+var attachStandard = exports.attachStandard = function attachStandard(validator) {
+  var properties = {
+    version: 1,
+    vendor: STANDARD_SCHEMA_VENDOR,
+    validate: function validate(value) {
+      var result = validator(value);
+      if (result.validate) {
+        return {
+          value: value
+        };
+      }
+      return {
+        issues: [{
+          message: result.message || "Validation failed"
+        }]
+      };
+    }
+  };
+  validator["~standard"] = properties;
+  return validator;
+};

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

@@ -2,7 +2,8 @@
  * String validation core module
  * Provides the base validation functionality for string values
  */
-import type { ValidateReturnType } from "../../Validate/type";
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
+import type { ValidateCoreReturnType, ValidateReturnType } from "../../Validate/type";
 /**
  * Creates a string validator with optional validation rules
  * @template T - Array of validation rules for strings
@@ -10,4 +11,4 @@ import type { ValidateReturnType } from "../../Validate/type";
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function that checks if the value is a string and applies validation rules
  */
-export declare const string: <T extends ValidateReturnType<string>[]>(option?: T, message?: string) => (value: string) => import("../../Validate/type").ValidateCoreReturnType<string>;
+export declare const string: <T extends ValidateReturnType<string>[]>(option?: T, message?: string) => ((value: string) => ValidateCoreReturnType<string>) & StandardSchemaV1<string, string>;

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.string = void 0;
 var _core = require("../../Validate/core");
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * String validation core module
  * Provides the base validation functionality for string values
@@ -18,7 +19,8 @@ var _core = require("../../Validate/core");
  * @returns {Function} - Validator function that checks if the value is a string and applies validation rules
  */
 var string = exports.string = function string(option, message) {
-  return function (value) {
+  var validator = function validator(value) {
     return (0, _core.core)("string")(value, option, message);
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

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

@@ -6,8 +6,9 @@
  * an auto-generated regular expression assembled from the parts, while the
  * inferred type is the corresponding TypeScript template literal type.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateType } from "../../Validate/type";
-type AnyValidator = (value?: any) => {
+export type TemplateLiteralAnyValidator = (value?: any) => {
     type: unknown;
 };
 /**
@@ -15,12 +16,12 @@ type AnyValidator = (value?: any) => {
  * 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) => {
+export type TemplateLiteralPart = string | TemplateLiteralAnyValidator;
+export 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>>;
+export type TagToTemplate<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "bigint" ? bigint : ValidateType<T>;
+export 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
@@ -51,5 +52,4 @@ export interface TemplateLiteralReturnType<T extends string> {
  * @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 {};
+export declare const templateLiteral: <const Parts extends readonly TemplateLiteralPart[]>(parts: Parts, message?: string) => ((value: BuildTemplateLiteral<Parts>) => TemplateLiteralReturnType<BuildTemplateLiteral<Parts>>) & StandardSchemaV1<BuildTemplateLiteral<Parts>, BuildTemplateLiteral<Parts>>;

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

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.templateLiteral = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 var _templateObject, _templateObject2, _templateObject3;
-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 _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
 /**
  * Template literal validation core module
  * Provides a validator that checks whether a string matches a template
@@ -17,7 +14,10 @@ function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.fre
  * an auto-generated regular expression assembled from the parts, while the
  * inferred type is the corresponding TypeScript template literal type.
  */
-
+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 _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
 // biome-ignore lint/suspicious/noExplicitAny: validator signatures vary
 
 /**
@@ -97,7 +97,7 @@ var templateLiteral = exports.templateLiteral = function templateLiteral(parts,
   }
   pattern += "$";
   var regex = new RegExp(pattern);
-  return function (value) {
+  var templateValidator = function templateValidator(value) {
     if (typeof value !== "string" || !regex.test(value)) {
       return {
         validate: false,
@@ -111,4 +111,5 @@ var templateLiteral = exports.templateLiteral = function templateLiteral(parts,
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(templateValidator);
 };

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

@@ -3,6 +3,7 @@
  * Provides a validator that accepts any value but exposes it as `unknown`
  * to keep callers honest about narrowing before use.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 /**
  * Return type produced by an `unknown` validator. Exposes the literal
  * `"unknown"` tag through the `type` field so `ValidateType<"unknown">` can
@@ -18,4 +19,4 @@ export interface UnknownReturnType {
  * Creates a validator that accepts any value but typed as unknown
  * @returns {Function} - Validator that always succeeds
  */
-export declare const unknown: () => ((value: unknown) => UnknownReturnType);
+export declare const unknown: () => ((value: unknown) => UnknownReturnType) & StandardSchemaV1<unknown, unknown>;

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.unknown = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Unknown validation core module
  * Provides a validator that accepts any value but exposes it as `unknown`
@@ -24,11 +25,12 @@ var unknownValidator = function unknownValidator(_value) {
     type: "unknown"
   };
 };
+var standardUnknownValidator = (0, _standardSchema.attachStandard)(unknownValidator);
 
 /**
  * Creates a validator that accepts any value but typed as unknown
  * @returns {Function} - Validator that always succeeds
  */
 var unknown = exports.unknown = function unknown() {
-  return unknownValidator;
+  return standardUnknownValidator;
 };

package/module/es5/types/array/chunk.d.ts

@@ -1,4 +1,3 @@
 import type { Length } from "../logic/length";
-type Chunk<T, N extends number, C extends unknown[] = [], R extends unknown[] = []> = T extends [infer F, ...infer L] ? Length<C> extends N ? Chunk<L, N, [F], [...R, C]> : Chunk<L, N, [...C, F], R> : Length<C> extends 0 ? Length<R> extends 0 ? T[] : R : [...R, C];
+export type Chunk<T, N extends number, C extends unknown[] = [], R extends unknown[] = []> = T extends [infer F, ...infer L] ? Length<C> extends N ? Chunk<L, N, [F], [...R, C]> : Chunk<L, N, [...C, F], R> : Length<C> extends 0 ? Length<R> extends 0 ? T[] : R : [...R, C];
 export type ChunkArrayType<T, N extends number> = Chunk<T, N>;
-export {};

package/module/es5/types/array/zip.d.ts

@@ -1,3 +1,5 @@
-type ZIP<T, O extends unknown[] = []> = T extends [infer Head, ...infer Tail] ? Head extends unknown[] ? ZIP<Tail, [...O, Head[number]]> : never : T extends [] ? O[] : T;
+export type ZIP<T, O extends unknown[] = []> = T extends [
+    infer Head,
+    ...infer Tail
+] ? Head extends unknown[] ? ZIP<Tail, [...O, Head[number]]> : never : T extends [] ? O[] : T;
 export type ZipArrayType<T extends unknown[][]> = ZIP<T>;
-export {};

package/module/es5/types/logic/binary1bitNor.d.ts

@@ -1,3 +1,2 @@
 export type Binary1bitNor<X extends `${0 | 1}`, Y extends `${0 | 1}`> = Binary1bitNorParser<X, Y>;
-type Binary1bitNorParser<X extends string, Y extends string> = X extends "1" ? "0" : Y extends "1" ? "0" : "1";
-export {};
+export type Binary1bitNorParser<X extends string, Y extends string> = X extends "1" ? "0" : Y extends "1" ? "0" : "1";

package/module/es5/types/logic/binaryFullAdder.d.ts

@@ -5,5 +5,4 @@ import type { LengthOfString } from "./lengthOfString";
 import type { ShiftString } from "./shiftString";
 import type { StringReverse } from "./stringReverse";
 export type BinaryFullAdder<X extends string, Y extends string, B extends number = LengthOfString<X>> = LengthOfString<X> extends LengthOfString<Y> ? FirstNChars<ShiftString<StringReverse<BinaryFullAdderParser<StringReverse<FirstNChars<X, B>>, StringReverse<FirstNChars<Y, B>>>>>, B> : never;
-type BinaryFullAdderParser<X extends string, Y extends string, A extends string = "", C extends string = "0"> = X extends `${infer F}${infer R}` ? Y extends `${infer F2}${infer R2}` ? BinaryHalfAdderParser<F, F2> extends `${infer F3}${infer R3}` ? BinaryHalfAdderParser<R3, C> extends `${infer F4}${infer R4}` ? BinaryFullAdderParser<R, R2, `${A}${R4}`, Binary1bitOrParser<F3, F4>> : never : never : never : `${A}${C}`;
-export {};
+export type BinaryFullAdderParser<X extends string, Y extends string, A extends string = "", C extends string = "0"> = X extends `${infer F}${infer R}` ? Y extends `${infer F2}${infer R2}` ? BinaryHalfAdderParser<F, F2> extends `${infer F3}${infer R3}` ? BinaryHalfAdderParser<R3, C> extends `${infer F4}${infer R4}` ? BinaryFullAdderParser<R, R2, `${A}${R4}`, Binary1bitOrParser<F3, F4>> : never : never : never : `${A}${C}`;

package/module/es5/types/math/divide.d.ts

@@ -2,5 +2,4 @@ import type { Add } from "./add";
 import type { Subtract } from "./subtract";
 import type { BGreaterThanA } from "../logic/bGreaterThanA";
 export type Divide<A extends number, B extends number> = A extends 0 ? never : B extends 0 ? never : `${A}` extends `-${infer N extends number}` ? `${B}` extends `-${infer M extends number}` ? DivideHelper<N, M> : `-${DivideHelper<N, B>}` extends `${infer R extends number}` ? R : never : `${B}` extends `-${infer M extends number}` ? `-${DivideHelper<A, M>}` extends `${infer R extends number}` ? R : never : DivideHelper<A, B>;
-type DivideHelper<X extends number, Y extends number, A extends number = 0> = BGreaterThanA<X, Y> extends true ? A : DivideHelper<Subtract<X, Y>, Y, Add<A, 1>>;
-export {};
+export type DivideHelper<X extends number, Y extends number, A extends number = 0> = BGreaterThanA<X, Y> extends true ? A : DivideHelper<Subtract<X, Y>, Y, Add<A, 1>>;

package/module/es5/types/math/multiply.d.ts

@@ -1,5 +1,4 @@
 import type { Add } from "./add";
 import type { Subtract } from "./subtract";
 export type Multiply<A extends number, B extends number> = MultiHelper<A, B>;
-type MultiHelper<X extends number, Y extends number, A extends number = 0> = `${X}` extends `-${infer N extends number}` ? `${Y}` extends `-${infer M extends number}` ? MultiHelper<N, M, A> : `-${MultiHelper<N, Y, A>}` extends `${infer R extends number}` ? R : never : `${Y}` extends `-${infer M extends number}` ? `-${MultiHelper<X, M, A>}` extends `${infer R extends number}` ? R : never : Y extends 0 ? A : MultiHelper<X, Subtract<Y, 1>, Add<X, A>>;
-export {};
+export type MultiHelper<X extends number, Y extends number, A extends number = 0> = `${X}` extends `-${infer N extends number}` ? `${Y}` extends `-${infer M extends number}` ? MultiHelper<N, M, A> : `-${MultiHelper<N, Y, A>}` extends `${infer R extends number}` ? R : never : `${Y}` extends `-${infer M extends number}` ? `-${MultiHelper<X, M, A>}` extends `${infer R extends number}` ? R : never : Y extends 0 ? A : MultiHelper<X, Subtract<Y, 1>, Add<X, A>>;

package/module/es5/types/object/pickDeep.d.ts

@@ -1,13 +1,12 @@
 import type { PickDeepKey } from "./pickDeepKey";
 import type { UnionToIntersection } from "../logic/unionToIntersection";
-type GetValueAtPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends object ? GetValueAtPath<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
-type ConstructNestedObject<P extends string, V> = P extends `${infer Key}.${infer Rest}` ? {
+export type GetValueAtPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends object ? GetValueAtPath<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+export type ConstructNestedObject<P extends string, V> = P extends `${infer Key}.${infer Rest}` ? {
     [K in Key]: ConstructNestedObject<Rest, V>;
 } : {
     [K in P]: V;
 };
-type ProcessKeys<T extends object, K extends readonly PickDeepKey<T>[]> = {
+export type ProcessKeys<T extends object, K extends readonly PickDeepKey<T>[]> = {
     [I in keyof K]: K[I] extends string ? ConstructNestedObject<K[I], GetValueAtPath<T, K[I]>> : never;
 }[number];
 export type PickDeep<T extends object, K extends readonly PickDeepKey<T>[]> = UnionToIntersection<ProcessKeys<T, K>>;
-export {};

package/module/types/array/chunk.d.ts

@@ -1,4 +1,3 @@
 import type { Length } from "../logic/length";
-type Chunk<T, N extends number, C extends unknown[] = [], R extends unknown[] = []> = T extends [infer F, ...infer L] ? Length<C> extends N ? Chunk<L, N, [F], [...R, C]> : Chunk<L, N, [...C, F], R> : Length<C> extends 0 ? Length<R> extends 0 ? T[] : R : [...R, C];
+export type Chunk<T, N extends number, C extends unknown[] = [], R extends unknown[] = []> = T extends [infer F, ...infer L] ? Length<C> extends N ? Chunk<L, N, [F], [...R, C]> : Chunk<L, N, [...C, F], R> : Length<C> extends 0 ? Length<R> extends 0 ? T[] : R : [...R, C];
 export type ChunkArrayType<T, N extends number> = Chunk<T, N>;
-export {};

package/module/types/array/zip.d.ts

@@ -1,3 +1,5 @@
-type ZIP<T, O extends unknown[] = []> = T extends [infer Head, ...infer Tail] ? Head extends unknown[] ? ZIP<Tail, [...O, Head[number]]> : never : T extends [] ? O[] : T;
+export type ZIP<T, O extends unknown[] = []> = T extends [
+    infer Head,
+    ...infer Tail
+] ? Head extends unknown[] ? ZIP<Tail, [...O, Head[number]]> : never : T extends [] ? O[] : T;
 export type ZipArrayType<T extends unknown[][]> = ZIP<T>;
-export {};

package/module/types/logic/binary1bitNor.d.ts

@@ -1,3 +1,2 @@
 export type Binary1bitNor<X extends `${0 | 1}`, Y extends `${0 | 1}`> = Binary1bitNorParser<X, Y>;
-type Binary1bitNorParser<X extends string, Y extends string> = X extends "1" ? "0" : Y extends "1" ? "0" : "1";
-export {};
+export type Binary1bitNorParser<X extends string, Y extends string> = X extends "1" ? "0" : Y extends "1" ? "0" : "1";

package/module/types/logic/binaryFullAdder.d.ts

@@ -5,5 +5,4 @@ import type { LengthOfString } from "./lengthOfString";
 import type { ShiftString } from "./shiftString";
 import type { StringReverse } from "./stringReverse";
 export type BinaryFullAdder<X extends string, Y extends string, B extends number = LengthOfString<X>> = LengthOfString<X> extends LengthOfString<Y> ? FirstNChars<ShiftString<StringReverse<BinaryFullAdderParser<StringReverse<FirstNChars<X, B>>, StringReverse<FirstNChars<Y, B>>>>>, B> : never;
-type BinaryFullAdderParser<X extends string, Y extends string, A extends string = "", C extends string = "0"> = X extends `${infer F}${infer R}` ? Y extends `${infer F2}${infer R2}` ? BinaryHalfAdderParser<F, F2> extends `${infer F3}${infer R3}` ? BinaryHalfAdderParser<R3, C> extends `${infer F4}${infer R4}` ? BinaryFullAdderParser<R, R2, `${A}${R4}`, Binary1bitOrParser<F3, F4>> : never : never : never : `${A}${C}`;
-export {};
+export type BinaryFullAdderParser<X extends string, Y extends string, A extends string = "", C extends string = "0"> = X extends `${infer F}${infer R}` ? Y extends `${infer F2}${infer R2}` ? BinaryHalfAdderParser<F, F2> extends `${infer F3}${infer R3}` ? BinaryHalfAdderParser<R3, C> extends `${infer F4}${infer R4}` ? BinaryFullAdderParser<R, R2, `${A}${R4}`, Binary1bitOrParser<F3, F4>> : never : never : never : `${A}${C}`;

package/module/types/math/divide.d.ts

@@ -2,5 +2,4 @@ import type { Add } from "./add";
 import type { Subtract } from "./subtract";
 import type { BGreaterThanA } from "../logic/bGreaterThanA";
 export type Divide<A extends number, B extends number> = A extends 0 ? never : B extends 0 ? never : `${A}` extends `-${infer N extends number}` ? `${B}` extends `-${infer M extends number}` ? DivideHelper<N, M> : `-${DivideHelper<N, B>}` extends `${infer R extends number}` ? R : never : `${B}` extends `-${infer M extends number}` ? `-${DivideHelper<A, M>}` extends `${infer R extends number}` ? R : never : DivideHelper<A, B>;
-type DivideHelper<X extends number, Y extends number, A extends number = 0> = BGreaterThanA<X, Y> extends true ? A : DivideHelper<Subtract<X, Y>, Y, Add<A, 1>>;
-export {};
+export type DivideHelper<X extends number, Y extends number, A extends number = 0> = BGreaterThanA<X, Y> extends true ? A : DivideHelper<Subtract<X, Y>, Y, Add<A, 1>>;

package/module/types/math/multiply.d.ts

@@ -1,5 +1,4 @@
 import type { Add } from "./add";
 import type { Subtract } from "./subtract";
 export type Multiply<A extends number, B extends number> = MultiHelper<A, B>;
-type MultiHelper<X extends number, Y extends number, A extends number = 0> = `${X}` extends `-${infer N extends number}` ? `${Y}` extends `-${infer M extends number}` ? MultiHelper<N, M, A> : `-${MultiHelper<N, Y, A>}` extends `${infer R extends number}` ? R : never : `${Y}` extends `-${infer M extends number}` ? `-${MultiHelper<X, M, A>}` extends `${infer R extends number}` ? R : never : Y extends 0 ? A : MultiHelper<X, Subtract<Y, 1>, Add<X, A>>;
-export {};
+export type MultiHelper<X extends number, Y extends number, A extends number = 0> = `${X}` extends `-${infer N extends number}` ? `${Y}` extends `-${infer M extends number}` ? MultiHelper<N, M, A> : `-${MultiHelper<N, Y, A>}` extends `${infer R extends number}` ? R : never : `${Y}` extends `-${infer M extends number}` ? `-${MultiHelper<X, M, A>}` extends `${infer R extends number}` ? R : never : Y extends 0 ? A : MultiHelper<X, Subtract<Y, 1>, Add<X, A>>;

package/module/types/object/pickDeep.d.ts

@@ -1,13 +1,12 @@
 import type { PickDeepKey } from "./pickDeepKey";
 import type { UnionToIntersection } from "../logic/unionToIntersection";
-type GetValueAtPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends object ? GetValueAtPath<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
-type ConstructNestedObject<P extends string, V> = P extends `${infer Key}.${infer Rest}` ? {
+export type GetValueAtPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends object ? GetValueAtPath<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+export type ConstructNestedObject<P extends string, V> = P extends `${infer Key}.${infer Rest}` ? {
     [K in Key]: ConstructNestedObject<Rest, V>;
 } : {
     [K in P]: V;
 };
-type ProcessKeys<T extends object, K extends readonly PickDeepKey<T>[]> = {
+export type ProcessKeys<T extends object, K extends readonly PickDeepKey<T>[]> = {
     [I in keyof K]: K[I] extends string ? ConstructNestedObject<K[I], GetValueAtPath<T, K[I]>> : never;
 }[number];
 export type PickDeep<T extends object, K extends readonly PickDeepKey<T>[]> = UnionToIntersection<ProcessKeys<T, K>>;
-export {};