@maroonedog/luq 0.1.0-alpha

package/dist/plugins/stringIpv4.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @luq-plugin
+ * @name stringIpv4
+ * @category string
+ * @description Validates IPv4 address format
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc791 - RFC 791: Internet Protocol - DARPA Internet Program Protocol Specification
+ * @see https://en.wikipedia.org/wiki/IPv4 - IPv4 Address Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates IPv4 address format (RFC 791 compliant)
+ * const validator = Builder()
+ *   .use(stringIpv4Plugin)
+ *   .for<{ ipAddress: string }>()
+ *   .v("ipAddress", (b) => b.string.ipv4())
+ *   .build();
+ *
+ * // ✅ VALID IPv4 addresses (RFC 791)
+ * validator.parse({ ipAddress: "192.168.1.1" });        // Private network (Class C)
+ * validator.parse({ ipAddress: "127.0.0.1" });          // Localhost/loopback
+ * validator.parse({ ipAddress: "8.8.8.8" });            // Google DNS
+ * validator.parse({ ipAddress: "0.0.0.0" });            // All zeros (any address)
+ * validator.parse({ ipAddress: "255.255.255.255" });    // Broadcast address
+ * validator.parse({ ipAddress: "10.0.0.1" });           // Private network (Class A)
+ * validator.parse({ ipAddress: "172.16.0.1" });         // Private network (Class B)
+ * validator.parse({ ipAddress: "203.0.113.1" });        // Documentation/test network
+ * validator.parse({ ipAddress: "1.1.1.1" });            // Cloudflare DNS
+ * validator.parse({ ipAddress: "192.0.2.146" });        // Documentation network
+ * validator.parse({ ipAddress: "198.51.100.1" });       // Documentation network
+ * validator.parse({ ipAddress: "169.254.1.1" });        // Link-local address
+ * validator.parse({ ipAddress: "224.0.0.1" });          // Multicast address
+ * validator.parse({ ipAddress: "239.255.255.255" });    // Local multicast
+ * validator.parse({ ipAddress: "1.2.3.4" });            // Simple valid address
+ * validator.parse({ ipAddress: "100.64.0.1" });         // Carrier-grade NAT
+ *
+ * // ❌ INVALID IPv4 addresses
+ * validator.parse({ ipAddress: "256.1.1.1" });          // Octet > 255
+ * validator.parse({ ipAddress: "192.168.1.256" });      // Last octet > 255
+ * validator.parse({ ipAddress: "300.300.300.300" });    // All octets > 255
+ * validator.parse({ ipAddress: "192.168.1" });          // Missing octet
+ * validator.parse({ ipAddress: "192.168" });            // Only 2 octets
+ * validator.parse({ ipAddress: "192" });                // Only 1 octet
+ * validator.parse({ ipAddress: "192.168.1.1.1" });      // Extra octet (5 octets)
+ * validator.parse({ ipAddress: "192.168.01.1" });       // Leading zeros (octal notation)
+ * validator.parse({ ipAddress: "192.168.001.1" });      // Multiple leading zeros
+ * validator.parse({ ipAddress: "192.168.-1.1" });       // Negative number
+ * validator.parse({ ipAddress: "192.168.1.-1" });       // Negative last octet
+ * validator.parse({ ipAddress: "not.an.ip.address" });  // Non-numeric text
+ * validator.parse({ ipAddress: "192.168.1.1/24" });     // CIDR notation
+ * validator.parse({ ipAddress: "192.168.1.1:8080" });   // With port number
+ * validator.parse({ ipAddress: "192.168.1." });         // Trailing dot
+ * validator.parse({ ipAddress: ".192.168.1.1" });       // Leading dot
+ * validator.parse({ ipAddress: "192..168.1.1" });       // Double dot
+ * validator.parse({ ipAddress: "192 168 1 1" });        // Spaces instead of dots
+ * validator.parse({ ipAddress: "192,168,1,1" });        // Commas instead of dots
+ * validator.parse({ ipAddress: "192-168-1-1" });        // Hyphens instead of dots
+ * validator.parse({ ipAddress: "" });                   // Empty string
+ * validator.parse({ ipAddress: "192.168.1.1 " });       // Trailing space
+ * validator.parse({ ipAddress: " 192.168.1.1" });       // Leading space
+ * validator.parse({ ipAddress: "192.168.a.1" });        // Letter in octet
+ * validator.parse({ ipAddress: "192.168.1.1." });       // Trailing dot after last octet
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IPv4 format
+ * @customError
+ * ```typescript
+ * .ipv4({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IPv4 format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringIpv4Plugin: import("../index").TypedPlugin<"stringIpv4", "ipv4", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringIpv4.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(n,e)=>{for(var a in e)l(n,a,{get:e[a],enumerable:!0})},y=(n,e,a,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of u(e))!g.call(n,r)&&r!==a&&l(n,r,{get:()=>e[r],enumerable:!(t=p(e,r))||t.enumerable});return n};var c=n=>y(l({},"__esModule",{value:!0}),n);var I={};d(I,{stringIpv4Plugin:()=>x});module.exports=c(I);var f=(n,e,a,t)=>{let s=(o=>(...m)=>{let i=o(...m);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:t}:i})(a);switch(n){case"conditional":return(o,...m)=>s(o,...m);case"fieldReference":return(o,...m)=>s(o,...m);case"multiFieldReference":return s;case"transform":return o=>s(o);case"arrayElement":return(o,...m)=>s(o,...m);case"context":return o=>s(o);default:return s}};function T(n){let{name:e,methodName:a,allowedTypes:t,category:r,impl:s}=n;return{name:e,methodName:a,allowedTypes:t,category:r,create:()=>f(r,a,s,e)}}var N=/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,x=T({name:"stringIpv4",methodName:"ipv4",allowedTypes:["string"],category:"standard",impl:n=>{let e=()=>"must be a valid IPv4 address",a=n?.messageFactory||(t=>`${t.path} ${e()}`);return{check:t=>typeof t!="string"?!1:N.test(t),code:"FORMAT_IPV4",getErrorMessage:(t,r)=>a({path:r,value:t,code:"FORMAT_IPV4"}),params:[n]}}});0&&(module.exports={stringIpv4Plugin});

package/dist/plugins/stringIpv4.mjs

@@ -0,0 +1 @@
+var T=(r,s,o,n)=>{let t=(e=>(...a)=>{let i=e(...a);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:n}:i})(o);switch(r){case"conditional":return(e,...a)=>t(e,...a);case"fieldReference":return(e,...a)=>t(e,...a);case"multiFieldReference":return t;case"transform":return e=>t(e);case"arrayElement":return(e,...a)=>t(e,...a);case"context":return e=>t(e);default:return t}};function l(r){let{name:s,methodName:o,allowedTypes:n,category:m,impl:t}=r;return{name:s,methodName:o,allowedTypes:n,category:m,create:()=>T(m,o,t,s)}}var p=/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,d=l({name:"stringIpv4",methodName:"ipv4",allowedTypes:["string"],category:"standard",impl:r=>{let s=()=>"must be a valid IPv4 address",o=r?.messageFactory||(n=>`${n.path} ${s()}`);return{check:n=>typeof n!="string"?!1:p.test(n),code:"FORMAT_IPV4",getErrorMessage:(n,m)=>o({path:m,value:n,code:"FORMAT_IPV4"}),params:[r]}}});export{d as stringIpv4Plugin};

package/dist/plugins/stringIpv6.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @luq-plugin
+ * @name stringIpv6
+ * @category string
+ * @description Validates IPv6 address format
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc4291 - RFC 4291: IP Version 6 Addressing Architecture
+ * @see https://en.wikipedia.org/wiki/IPv6 - IPv6 Address Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates IPv6 address format (RFC 4291 compliant)
+ * const validator = Builder()
+ *   .use(stringIpv6Plugin)
+ *   .for<{ ipv6Address: string }>()
+ *   .v("ipv6Address", (b) => b.string.ipv6())
+ *   .build();
+ *
+ * // ✅ VALID IPv6 addresses (RFC 4291)
+ * // Full format (128-bit address)
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334" });
+ * validator.parse({ ipv6Address: "2001:0DB8:85A3:0000:0000:8A2E:0370:7334" }); // Case insensitive
+ *
+ * // Leading zeros omitted
+ * validator.parse({ ipv6Address: "2001:db8:85a3:0:0:8a2e:370:7334" });
+ * validator.parse({ ipv6Address: "2001:db8:85a3:1:1:8a2e:370:7334" });
+ *
+ * // Compressed format with :: (consecutive zeros)
+ * validator.parse({ ipv6Address: "2001:db8:85a3::8a2e:370:7334" });
+ * validator.parse({ ipv6Address: "2001:db8::1" });
+ * validator.parse({ ipv6Address: "2001:db8::" });
+ * validator.parse({ ipv6Address: "::2001:db8:85a3:0:0:8a2e:370:7334" });
+ * validator.parse({ ipv6Address: "2001:db8:85a3:0:0:8a2e::" });
+ *
+ * // Special addresses
+ * validator.parse({ ipv6Address: "::1" });                    // IPv6 loopback
+ * validator.parse({ ipv6Address: "::" });                     // All zeros (unspecified)
+ * validator.parse({ ipv6Address: "::ffff:0:0" });             // IPv4-mapped prefix
+ * validator.parse({ ipv6Address: "::ffff:192.0.2.1" });       // IPv4-mapped IPv6
+ * validator.parse({ ipv6Address: "::ffff:c000:0201" });       // IPv4-mapped (hex format)
+ * validator.parse({ ipv6Address: "2001:db8::192.0.2.1" });    // IPv4 suffix notation
+ *
+ * // Link-local addresses
+ * validator.parse({ ipv6Address: "fe80::1" });                // Link-local
+ * validator.parse({ ipv6Address: "fe80::1%lo0" });            // With zone identifier
+ * validator.parse({ ipv6Address: "fe80::1%eth0" });           // With interface name
+ * validator.parse({ ipv6Address: "fe80::200:f8ff:fe21:67cf%en0" }); // Full link-local with zone
+ *
+ * // Multicast addresses
+ * validator.parse({ ipv6Address: "ff02::1" });                // All nodes multicast
+ * validator.parse({ ipv6Address: "ff02::2" });                // All routers multicast
+ *
+ * // Documentation addresses
+ * validator.parse({ ipv6Address: "2001:db8::1" });            // Documentation prefix
+ * validator.parse({ ipv6Address: "2001:db8:85a3::8a2e:370:7334" }); // RFC 3849 example
+ *
+ * // Edge cases
+ * validator.parse({ ipv6Address: "1:2:3:4:5:6:7:8" });        // All single digits
+ * validator.parse({ ipv6Address: "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" }); // All ones
+ *
+ * // ❌ INVALID IPv6 addresses
+ * validator.parse({ ipv6Address: "2001:0db8:85a3::8a2e::7334" });        // Double :: (not allowed)
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334:extra" }); // Too many groups
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370" }); // Too few groups without ::
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:733g" }); // Invalid hex char (g)
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:73345" }); // Group too long (5 chars)
+ * validator.parse({ ipv6Address: "2001::db8::85a3" });                   // Multiple :: not allowed
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:" }); // Trailing colon
+ * validator.parse({ ipv6Address: ":2001:0db8:85a3:0000:0000:8a2e:0370:7334" }); // Leading colon (not ::)
+ * validator.parse({ ipv6Address: "2001-0db8-85a3-0000-0000-8a2e-0370-7334" }); // Hyphens instead of colons
+ * validator.parse({ ipv6Address: "2001.0db8.85a3.0000.0000.8a2e.0370.7334" }); // Dots instead of colons
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334/64" }); // With CIDR notation
+ * validator.parse({ ipv6Address: "gggg::1" });                           // Invalid hex chars
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:::8a2e:0370:7334" });   // Triple colon
+ * validator.parse({ ipv6Address: "" });                                  // Empty string
+ * validator.parse({ ipv6Address: "not:an:ipv6:address" });               // Non-hex text
+ * validator.parse({ ipv6Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334 " }); // Trailing space
+ * validator.parse({ ipv6Address: " 2001:0db8:85a3:0000:0000:8a2e:0370:7334" }); // Leading space
+ * validator.parse({ ipv6Address: "::ffff:256.1.1.1" });                 // Invalid IPv4 in mapping
+ * validator.parse({ ipv6Address: "::ffff:192.168.1" });                 // Incomplete IPv4 in mapping
+ * validator.parse({ ipv6Address: "192.168.1.1" });                      // Plain IPv4 address
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IPv6 format
+ * @customError
+ * ```typescript
+ * .ipv6({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IPv6 format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringIpv6Plugin: import("../index").TypedPlugin<"stringIpv6", "ipv6", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringIpv6.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(n,e)=>{for(var a in e)l(n,a,{get:e[a],enumerable:!0})},y=(n,e,a,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of u(e))!g.call(n,r)&&r!==a&&l(n,r,{get:()=>e[r],enumerable:!(t=p(e,r))||t.enumerable});return n};var f=n=>y(l({},"__esModule",{value:!0}),n);var I={};d(I,{stringIpv6Plugin:()=>x});module.exports=f(I);var c=(n,e,a,t)=>{let s=(o=>(...m)=>{let i=o(...m);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:t}:i})(a);switch(n){case"conditional":return(o,...m)=>s(o,...m);case"fieldReference":return(o,...m)=>s(o,...m);case"multiFieldReference":return s;case"transform":return o=>s(o);case"arrayElement":return(o,...m)=>s(o,...m);case"context":return o=>s(o);default:return s}};function T(n){let{name:e,methodName:a,allowedTypes:t,category:r,impl:s}=n;return{name:e,methodName:a,allowedTypes:t,category:r,create:()=>c(r,a,s,e)}}var N=/^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/,x=T({name:"stringIpv6",methodName:"ipv6",allowedTypes:["string"],category:"standard",impl:n=>{let e=()=>"must be a valid IPv6 address",a=n?.messageFactory||(t=>`${t.path} ${e()}`);return{check:t=>typeof t!="string"?!1:N.test(t),code:"FORMAT_IPV6",getErrorMessage:(t,r)=>a({path:r,value:t,code:"FORMAT_IPV6"}),params:[n]}}});0&&(module.exports={stringIpv6Plugin});

package/dist/plugins/stringIpv6.mjs

@@ -0,0 +1 @@
+var T=(r,s,o,n)=>{let t=(e=>(...a)=>{let i=e(...a);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:n}:i})(o);switch(r){case"conditional":return(e,...a)=>t(e,...a);case"fieldReference":return(e,...a)=>t(e,...a);case"multiFieldReference":return t;case"transform":return e=>t(e);case"arrayElement":return(e,...a)=>t(e,...a);case"context":return e=>t(e);default:return t}};function l(r){let{name:s,methodName:o,allowedTypes:n,category:m,impl:t}=r;return{name:s,methodName:o,allowedTypes:n,category:m,create:()=>T(m,o,t,s)}}var p=/^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/,d=l({name:"stringIpv6",methodName:"ipv6",allowedTypes:["string"],category:"standard",impl:r=>{let s=()=>"must be a valid IPv6 address",o=r?.messageFactory||(n=>`${n.path} ${s()}`);return{check:n=>typeof n!="string"?!1:p.test(n),code:"FORMAT_IPV6",getErrorMessage:(n,m)=>o({path:m,value:n,code:"FORMAT_IPV6"}),params:[r]}}});export{d as stringIpv6Plugin};

package/dist/plugins/stringIri.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @luq-plugin
+ * @name stringIri
+ * @category string
+ * @description Validates IRI (Internationalized Resource Identifier) format (RFC 3987)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc3987 - RFC 3987: Internationalized Resource Identifiers (IRIs)
+ * @see https://en.wikipedia.org/wiki/Internationalized_Resource_Identifier - IRI Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates IRI format (RFC 3987 compliant)
+ * const validator = Builder()
+ *   .use(stringIriPlugin)
+ *   .for<{ identifier: string }>()
+ *   .v("identifier", (b) => b.string.iri())
+ *   .build();
+ *
+ * // ✅ VALID IRI formats (RFC 3987)
+ * // Standard ASCII URIs (subset of IRI)
+ * validator.parse({ identifier: "https://www.example.com/path" });    // Regular HTTP URL
+ * validator.parse({ identifier: "http://example.org:8080/api/v1" }); // With port and path
+ * validator.parse({ identifier: "ftp://files.example.com/file.txt" }); // FTP scheme
+ * validator.parse({ identifier: "mailto:user@example.com" });         // Email scheme
+ * validator.parse({ identifier: "tel:+1-555-123-4567" });            // Telephone scheme
+ *
+ * // Internationalized domain names and paths (Unicode)
+ * validator.parse({ identifier: "https://例え.jp/パス" });              // Japanese characters
+ * validator.parse({ identifier: "http://münchen.de/straße" });       // German umlauts
+ * validator.parse({ identifier: "https://café.fr/menu" });           // French accents
+ * validator.parse({ identifier: "http://домен.рф/путь" });           // Cyrillic script
+ * validator.parse({ identifier: "https://测试.cn/路径" });             // Chinese characters
+ * validator.parse({ identifier: "http://테스트.kr/경로" });             // Korean characters
+ * validator.parse({ identifier: "https://тест.bg/път" });            // Bulgarian Cyrillic
+ * validator.parse({ identifier: "http://δοκιμή.gr/διαδρομή" });      // Greek characters
+ * validator.parse({ identifier: "https://परीक्षा.in/पथ" });           // Hindi/Devanagari
+ * validator.parse({ identifier: "http://اختبار.sa/مسار" });           // Arabic script
+ *
+ * // Internationalized email addresses
+ * validator.parse({ identifier: "mailto:ユーザー@例え.jp" });          // Japanese email
+ * validator.parse({ identifier: "mailto:utilisateur@café.fr" });     // French domain
+ * validator.parse({ identifier: "mailto:пользователь@домен.рф" });    // Cyrillic email
+ *
+ * // Mixed ASCII and Unicode
+ * validator.parse({ identifier: "https://api.例え.jp/v1/users" });    // Mixed path
+ * validator.parse({ identifier: "https://例え.example.com/path" });   // Mixed domain
+ * validator.parse({ identifier: "ftp://files.café.com/données.txt" }); // Mixed filename
+ *
+ * // Various schemes with Unicode
+ * validator.parse({ identifier: "ldap://服务器.com/cn=用户,dc=例子,dc=com" }); // LDAP with Chinese
+ * validator.parse({ identifier: "news://nieuws.nl/groep.测试" });     // News with mixed Unicode
+ * validator.parse({ identifier: "urn:isbn:978-3-86680-192-9" });     // URN (ASCII)
+ *
+ * // Edge cases
+ * validator.parse({ identifier: "custom-scheme://测试.example/路径" }); // Custom scheme with Unicode
+ * validator.parse({ identifier: "x-proprietary://例え.internal" });   // Non-standard scheme
+ * validator.parse({ identifier: "data:text/plain;charset=utf-8,你好" }); // Data URI with Unicode
+ *
+ * // ❌ INVALID IRI formats
+ * validator.parse({ identifier: "not-an-iri" });                     // No scheme separator
+ * validator.parse({ identifier: "://missing-scheme.com" });          // Missing scheme
+ * validator.parse({ identifier: "http://" });                        // Missing authority
+ * validator.parse({ identifier: "https:/" });                        // Malformed scheme separator
+ * validator.parse({ identifier: "" });                              // Empty string
+ * validator.parse({ identifier: "http://exam ple.com" });            // Space in authority
+ * validator.parse({ identifier: "https://example.com/path with spaces" }); // Spaces in path
+ * validator.parse({ identifier: "http://example.com/path\twith\ttabs" }); // Tab characters
+ * validator.parse({ identifier: "https://example.com/path\nwith\nnewlines" }); // Newline characters
+ * validator.parse({ identifier: "http://example.com/path\rwith\rcarriage" }); // Carriage returns
+ * validator.parse({ identifier: "ftp://example.com\x00null" });      // Null character (control char)
+ * validator.parse({ identifier: "https://example.com\x01control" }); // Control character
+ * validator.parse({ identifier: "http://example.com\x7Fdel" });      // DEL character
+ *
+ * // Malformed schemes
+ * validator.parse({ identifier: "123://invalid-scheme.com" });       // Scheme starting with number
+ * validator.parse({ identifier: "-http://invalid-scheme.com" });     // Scheme starting with hyphen
+ * validator.parse({ identifier: ".http://invalid-scheme.com" });     // Scheme starting with dot
+ * validator.parse({ identifier: "ht@tp://invalid-char.com" });       // Invalid char in scheme
+ * validator.parse({ identifier: "ht tp://space-in-scheme.com" });    // Space in scheme
+ *
+ * // Missing or empty components
+ * validator.parse({ identifier: "http:" });                          // Scheme only
+ * validator.parse({ identifier: ":" });                             // Just separator
+ * validator.parse({ identifier: "http://example.com:" });           // Trailing colon
+ *
+ * // Invalid Unicode sequences (rare but possible)
+ * validator.parse({ identifier: "https://example.com/\uFFFD" });     // Replacement character
+ * validator.parse({ identifier: "http://\uFEFF.example.com" });      // BOM character
+ *
+ * // Leading/trailing whitespace
+ * validator.parse({ identifier: " https://example.com" });          // Leading space
+ * validator.parse({ identifier: "https://example.com " });          // Trailing space
+ * validator.parse({ identifier: "\thttps://example.com" });         // Leading tab
+ * validator.parse({ identifier: "https://example.com\n" });         // Trailing newline
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IRI format
+ * @customError
+ * ```typescript
+ * .iri({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IRI format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringIriPlugin: import("../index").TypedPlugin<"stringIri", "iri", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringIri.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(e,n)=>{for(var a in n)l(e,a,{get:n[a],enumerable:!0})},y=(e,n,a,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of p(n))!g.call(e,r)&&r!==a&&l(e,r,{get:()=>n[r],enumerable:!(t=u(n,r))||t.enumerable});return e};var c=e=>y(l({},"__esModule",{value:!0}),e);var h={};d(h,{stringIriPlugin:()=>x});module.exports=c(h);var f=(e,n,a,t)=>{let o=(s=>(...i)=>{let m=s(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:t}:m})(a);switch(e){case"conditional":return(s,...i)=>o(s,...i);case"fieldReference":return(s,...i)=>o(s,...i);case"multiFieldReference":return o;case"transform":return s=>o(s);case"arrayElement":return(s,...i)=>o(s,...i);case"context":return s=>o(s);default:return o}};function T(e){let{name:n,methodName:a,allowedTypes:t,category:r,impl:o}=e;return{name:n,methodName:a,allowedTypes:t,category:r,create:()=>f(r,a,o,n)}}var I=/^[a-zA-Z][a-zA-Z0-9+.-]*:(?:\/\/)?[^\s]*$/;function N(e){if(!I.test(e)||/[\x00-\x1F\x7F\s]/.test(e))return!1;try{return new URL(e),!0}catch{let n=e.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):(.+)$/);if(!n)return!1;let[,a,t]=n;return!(!a||a.length===0||!t||t.length===0)}}var x=T({name:"stringIri",methodName:"iri",allowedTypes:["string"],category:"standard",impl:e=>{let n=()=>"must be a valid IRI (RFC 3987)",a=e?.messageFactory||(t=>`${t.path} ${n()}`);return{check:t=>typeof t!="string"?!1:N(t),code:"FORMAT_IRI",getErrorMessage:(t,r)=>a({path:r,value:t,code:"FORMAT_IRI"}),params:[e]}}});0&&(module.exports={stringIriPlugin});

package/dist/plugins/stringIri.mjs

@@ -0,0 +1 @@
+var T=(n,s,a,e)=>{let r=(t=>(...o)=>{let m=t(...o);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:e}:m})(a);switch(n){case"conditional":return(t,...o)=>r(t,...o);case"fieldReference":return(t,...o)=>r(t,...o);case"multiFieldReference":return r;case"transform":return t=>r(t);case"arrayElement":return(t,...o)=>r(t,...o);case"context":return t=>r(t);default:return r}};function l(n){let{name:s,methodName:a,allowedTypes:e,category:i,impl:r}=n;return{name:s,methodName:a,allowedTypes:e,category:i,create:()=>T(i,a,r,s)}}var u=/^[a-zA-Z][a-zA-Z0-9+.-]*:(?:\/\/)?[^\s]*$/;function p(n){if(!u.test(n)||/[\x00-\x1F\x7F\s]/.test(n))return!1;try{return new URL(n),!0}catch{let s=n.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):(.+)$/);if(!s)return!1;let[,a,e]=s;return!(!a||a.length===0||!e||e.length===0)}}var y=l({name:"stringIri",methodName:"iri",allowedTypes:["string"],category:"standard",impl:n=>{let s=()=>"must be a valid IRI (RFC 3987)",a=n?.messageFactory||(e=>`${e.path} ${s()}`);return{check:e=>typeof e!="string"?!1:p(e),code:"FORMAT_IRI",getErrorMessage:(e,i)=>a({path:i,value:e,code:"FORMAT_IRI"}),params:[n]}}});export{y as stringIriPlugin};

package/dist/plugins/stringIriReference.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @luq-plugin
+ * @name stringIriReference
+ * @category string
+ * @description Validates IRI-reference format (RFC 3987) - can be absolute or relative
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringIriReferencePlugin)
+ *   .for<{ ref: string }>()
+ *   .v("ref", (b) => b.string.iriReference())
+ *   .build();
+ *
+ * // Valid: https://example.com/path
+ * // Valid: /relative/path
+ * // Valid: ../parent
+ * // Valid: #fragment
+ * // Valid: ?query=param
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks IRI-reference format
+ * @customError
+ * ```typescript
+ * .iriReference({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid IRI-reference format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringIriReferencePlugin: import("../index").TypedPlugin<"stringIriReference", "iriReference", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringIriReference.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(e,t)=>{for(var r in t)l(e,r,{get:t[r],enumerable:!0})},y=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of p(t))!g.call(e,a)&&a!==r&&l(e,a,{get:()=>t[a],enumerable:!(n=u(t,a))||n.enumerable});return e};var c=e=>y(l({},"__esModule",{value:!0}),e);var I={};d(I,{stringIriReferencePlugin:()=>h});module.exports=c(I);var f=(e,t,r,n)=>{let i=(s=>(...o)=>{let m=s(...o);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:n}:m})(r);switch(e){case"conditional":return(s,...o)=>i(s,...o);case"fieldReference":return(s,...o)=>i(s,...o);case"multiFieldReference":return i;case"transform":return s=>i(s);case"arrayElement":return(s,...o)=>i(s,...o);case"context":return s=>i(s);default:return i}};function T(e){let{name:t,methodName:r,allowedTypes:n,category:a,impl:i}=e;return{name:t,methodName:r,allowedTypes:n,category:a,create:()=>f(a,r,i,t)}}function N(e){if(e==="")return!0;if(/[\x00-\x1F\x7F]/.test(e))return!1;let t=e.split(/[?#]/)[0];if(/\s/.test(t))return!1;if(/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(e))try{return new URL(e),!0}catch{return/^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/.test(e)}return e.startsWith("//")?e.length>2&&!e.slice(2).includes("//"):e.startsWith("/")||e.startsWith("./")||e.startsWith("../")||e.startsWith("?")||e.startsWith("#")?!0:!e.split(/[/?#]/)[0].includes(":")}var h=T({name:"stringIriReference",methodName:"iriReference",allowedTypes:["string"],category:"standard",impl:e=>{let t=()=>"must be a valid IRI-reference (RFC 3987)",r=e?.messageFactory||(n=>`${n.path} ${t()}`);return{check:n=>typeof n!="string"?!1:N(n),code:"FORMAT_IRI_REFERENCE",getErrorMessage:(n,a)=>r({path:a,value:n,code:"FORMAT_IRI_REFERENCE"}),params:[e]}}});0&&(module.exports={stringIriReferencePlugin});

package/dist/plugins/stringIriReference.mjs

@@ -0,0 +1 @@
+var T=(e,a,s,n)=>{let r=(t=>(...i)=>{let m=t(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:n}:m})(s);switch(e){case"conditional":return(t,...i)=>r(t,...i);case"fieldReference":return(t,...i)=>r(t,...i);case"multiFieldReference":return r;case"transform":return t=>r(t);case"arrayElement":return(t,...i)=>r(t,...i);case"context":return t=>r(t);default:return r}};function l(e){let{name:a,methodName:s,allowedTypes:n,category:o,impl:r}=e;return{name:a,methodName:s,allowedTypes:n,category:o,create:()=>T(o,s,r,a)}}function u(e){if(e==="")return!0;if(/[\x00-\x1F\x7F]/.test(e))return!1;let a=e.split(/[?#]/)[0];if(/\s/.test(a))return!1;if(/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(e))try{return new URL(e),!0}catch{return/^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/.test(e)}return e.startsWith("//")?e.length>2&&!e.slice(2).includes("//"):e.startsWith("/")||e.startsWith("./")||e.startsWith("../")||e.startsWith("?")||e.startsWith("#")?!0:!e.split(/[/?#]/)[0].includes(":")}var d=l({name:"stringIriReference",methodName:"iriReference",allowedTypes:["string"],category:"standard",impl:e=>{let a=()=>"must be a valid IRI-reference (RFC 3987)",s=e?.messageFactory||(n=>`${n.path} ${a()}`);return{check:n=>typeof n!="string"?!1:u(n),code:"FORMAT_IRI_REFERENCE",getErrorMessage:(n,o)=>s({path:o,value:n,code:"FORMAT_IRI_REFERENCE"}),params:[e]}}});export{d as stringIriReferencePlugin};

package/dist/plugins/stringJsonPointer.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @luq-plugin
+ * @name stringJsonPointer
+ * @category string
+ * @description Validates JSON Pointer format (RFC 6901)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc6901 - RFC 6901: JavaScript Object Notation (JSON) Pointer
+ * @see https://datatracker.ietf.org/doc/html/rfc6901 - JSON Pointer Specification
+ * @example
+ * ```typescript
+ * // Basic usage - validates JSON Pointer format (RFC 6901 compliant)
+ * const validator = Builder()
+ *   .use(stringJsonPointerPlugin)
+ *   .for<{ pointer: string }>()
+ *   .v("pointer", (b) => b.string.jsonPointer())
+ *   .build();
+ *
+ * // ✅ VALID JSON Pointers (RFC 6901)
+ * validator.parse({ pointer: "" });                    // Empty string (points to root document)
+ * validator.parse({ pointer: "/" });                   // Points to empty property name
+ * validator.parse({ pointer: "/foo" });                // Simple property access
+ * validator.parse({ pointer: "/foo/bar" });            // Nested property access
+ * validator.parse({ pointer: "/foo/0" });              // Array element by index
+ * validator.parse({ pointer: "/foo/0/bar" });          // Property of array element
+ * validator.parse({ pointer: "/users/123/name" });     // Deep nested access
+ * validator.parse({ pointer: "/data/items/0/id" });    // Array element property
+ *
+ * // Escaped characters (RFC 6901 escape sequences)
+ * validator.parse({ pointer: "/~0" });                 // Escaped ~ character (represents "~")
+ * validator.parse({ pointer: "/~1" });                 // Escaped / character (represents "/")
+ * validator.parse({ pointer: "/~0~1" });               // Both escapes (represents "~/")
+ * validator.parse({ pointer: "/foo~1bar" });           // Forward slash escaped in middle
+ * validator.parse({ pointer: "/~0field" });            // Tilde escaped at start of token
+ * validator.parse({ pointer: "/field~0" });            // Tilde escaped at end of token
+ * validator.parse({ pointer: "/foo~0bar~1baz" });      // Multiple escapes in one token
+ *
+ * // Real-world JSON structure examples
+ * // For JSON: { "user": { "settings": { "theme": "dark" } } }
+ * validator.parse({ pointer: "/user" });               // Access user object
+ * validator.parse({ pointer: "/user/settings" });      // Access nested settings
+ * validator.parse({ pointer: "/user/settings/theme" }); // Access theme value
+ *
+ * // For JSON: { "items": [{"name": "Item1"}, {"name": "Item2"}] }
+ * validator.parse({ pointer: "/items" });              // Access items array
+ * validator.parse({ pointer: "/items/0" });            // First item
+ * validator.parse({ pointer: "/items/1" });            // Second item
+ * validator.parse({ pointer: "/items/0/name" });       // Name of first item
+ *
+ * // For JSON with special property names
+ * // { "": "empty name", "a/b": "slash in name", "c~d": "tilde in name" }
+ * validator.parse({ pointer: "/" });                   // Empty property name
+ * validator.parse({ pointer: "/a~1b" });               // Property "a/b" (/ escaped as ~1)
+ * validator.parse({ pointer: "/c~0d" });               // Property "c~d" (~ escaped as ~0)
+ *
+ * // Edge cases
+ * validator.parse({ pointer: "/0" });                  // String "0" as property name
+ * validator.parse({ pointer: "/-1" });                 // String "-1" as property name
+ * validator.parse({ pointer: "/123" });                // Numeric string as property name
+ * validator.parse({ pointer: "/true" });               // Boolean string as property name
+ * validator.parse({ pointer: "/null" });               // Null string as property name
+ *
+ * // ❌ INVALID JSON Pointers
+ * validator.parse({ pointer: "foo" });                 // Missing initial slash
+ * validator.parse({ pointer: "foo/bar" });             // Missing initial slash
+ * validator.parse({ pointer: "/foo/" });               // Trailing slash (points to empty property)
+ * validator.parse({ pointer: "/foo//" });              // Double slash (empty token)
+ * validator.parse({ pointer: "/~" });                  // Incomplete escape sequence
+ * validator.parse({ pointer: "/~2" });                 // Invalid escape sequence (only ~0 and ~1 allowed)
+ * validator.parse({ pointer: "/~3" });                 // Invalid escape sequence
+ * validator.parse({ pointer: "/foo~" });               // Incomplete escape at end
+ * validator.parse({ pointer: "/foo~bar" });            // Tilde without proper escape
+ * validator.parse({ pointer: "/foo~/bar" });           // Incomplete escape in middle
+ * validator.parse({ pointer: "~/foo" });               // Escape at start without leading slash
+ * validator.parse({ pointer: "/foo bar" });            // Space in token (technically valid by RFC but often problematic)
+ * validator.parse({ pointer: "/foo\tbar" });           // Tab character
+ * validator.parse({ pointer: "/foo\nbar" });           // Newline character
+ * validator.parse({ pointer: "/foo\rbar" });           // Carriage return
+ * validator.parse({ pointer: "/foo\"bar" });           // Double quote (valid but can be problematic)
+ * validator.parse({ pointer: "/foo'bar" });            // Single quote (valid but can be problematic)
+ * validator.parse({ pointer: "/foo\\bar" });           // Backslash (valid but can be confusing)
+ * validator.parse({ pointer: " /foo" });               // Leading space
+ * validator.parse({ pointer: "/foo " });               // Trailing space
+ * validator.parse({ pointer: "//foo" });               // Double slash at start
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks JSON Pointer format
+ * @customError
+ * ```typescript
+ * .jsonPointer({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid JSON Pointer format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringJsonPointerPlugin: import("../index").TypedPlugin<"stringJsonPointer", "jsonPointer", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringJsonPointer.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(n,e)=>{for(var a in e)l(n,a,{get:e[a],enumerable:!0})},y=(n,e,a,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of u(e))!g.call(n,r)&&r!==a&&l(n,r,{get:()=>e[r],enumerable:!(t=p(e,r))||t.enumerable});return n};var c=n=>y(l({},"__esModule",{value:!0}),n);var P={};d(P,{stringJsonPointerPlugin:()=>x});module.exports=c(P);var N=(n,e,a,t)=>{let s=(o=>(...i)=>{let m=o(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:t}:m})(a);switch(n){case"conditional":return(o,...i)=>s(o,...i);case"fieldReference":return(o,...i)=>s(o,...i);case"multiFieldReference":return s;case"transform":return o=>s(o);case"arrayElement":return(o,...i)=>s(o,...i);case"context":return o=>s(o);default:return s}};function T(n){let{name:e,methodName:a,allowedTypes:t,category:r,impl:s}=n;return{name:e,methodName:a,allowedTypes:t,category:r,create:()=>N(r,a,s,e)}}var f=/^(\/([^~]|(~[01]))*)*$/,x=T({name:"stringJsonPointer",methodName:"jsonPointer",allowedTypes:["string"],category:"standard",impl:n=>{let e=()=>"must be a valid JSON Pointer (RFC 6901)",a=n?.messageFactory||(t=>`${t.path} ${e()}`);return{check:t=>typeof t!="string"?!1:f.test(t),code:"FORMAT_JSON_POINTER",getErrorMessage:(t,r)=>a({path:r,value:t,code:"FORMAT_JSON_POINTER"}),params:[n]}}});0&&(module.exports={stringJsonPointerPlugin});

package/dist/plugins/stringJsonPointer.mjs

@@ -0,0 +1 @@
+var T=(r,s,o,n)=>{let t=(e=>(...a)=>{let m=e(...a);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:n}:m})(o);switch(r){case"conditional":return(e,...a)=>t(e,...a);case"fieldReference":return(e,...a)=>t(e,...a);case"multiFieldReference":return t;case"transform":return e=>t(e);case"arrayElement":return(e,...a)=>t(e,...a);case"context":return e=>t(e);default:return t}};function l(r){let{name:s,methodName:o,allowedTypes:n,category:i,impl:t}=r;return{name:s,methodName:o,allowedTypes:n,category:i,create:()=>T(i,o,t,s)}}var p=/^(\/([^~]|(~[01]))*)*$/,d=l({name:"stringJsonPointer",methodName:"jsonPointer",allowedTypes:["string"],category:"standard",impl:r=>{let s=()=>"must be a valid JSON Pointer (RFC 6901)",o=r?.messageFactory||(n=>`${n.path} ${s()}`);return{check:n=>typeof n!="string"?!1:p.test(n),code:"FORMAT_JSON_POINTER",getErrorMessage:(n,i)=>o({path:i,value:n,code:"FORMAT_JSON_POINTER"}),params:[r]}}});export{d as stringJsonPointerPlugin};

package/dist/plugins/stringMax.d.ts

@@ -0,0 +1,43 @@
+import { ValidationOptions, MessageContext } from "../core/plugin/types";
+export interface StringMaxContext extends MessageContext {
+    max: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name stringMax
+ * @category standard
+ * @description Validates that a string does not exceed the specified maximum length
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * // Basic usage - set maximum string length
+ * const validator = Builder()
+ *   .use(stringMaxPlugin)
+ *   .for<UserProfile>()
+ *   .v("username", (b) => b.string.max(20))
+ *   .v("bio", (b) => b.string.max(500))
+ *   .build();
+ *
+ * // Combined with min for length range
+ * builder.v("description", b => b.string.min(10).max(200))
+ * ```
+ * @params
+ * - max: number - Maximum character count
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if string length is within the maximum
+ * @customError
+ * ```typescript
+ * .max(100, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must not exceed ${params.max} characters (current: ${value.length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringMaxPlugin: import("../index").TypedPlugin<"stringMax", "max", (maxLength: number, options?: ValidationOptions<StringMaxContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<StringMaxContext>)[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringMax.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(n,t)=>{for(var r in t)l(n,r,{get:t[r],enumerable:!0})},y=(n,t,r,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of u(t))!g.call(n,e)&&e!==r&&l(n,e,{get:()=>t[e],enumerable:!(i=p(t,e))||i.enumerable});return n};var c=n=>y(l({},"__esModule",{value:!0}),n);var h={};d(h,{stringMaxPlugin:()=>I});module.exports=c(h);var f=(n,t,r,i)=>{let o=(a=>(...s)=>{let m=a(...s);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:i}:m})(r);switch(n){case"conditional":return(a,...s)=>o(a,...s);case"fieldReference":return(a,...s)=>o(a,...s);case"multiFieldReference":return o;case"transform":return a=>o(a);case"arrayElement":return(a,...s)=>o(a,...s);case"context":return a=>o(a);default:return o}};function T(n){let{name:t,methodName:r,allowedTypes:i,category:e,impl:o}=n;return{name:t,methodName:r,allowedTypes:i,category:e,create:()=>f(e,r,o,t)}}var x="stringMax",N=["string"],I=T({name:"stringMax",methodName:"max",allowedTypes:N,category:"standard",impl:(n,t)=>{let r=t?.code||x,i=t?.messageFactory||(e=>`String must have at most ${e.max} characters, but got ${e.actual}`);if(typeof n!="number"||n<0)throw new Error(`Invalid maxLength: ${n}`);return{check:e=>typeof e!="string"?!0:e.length<=n,code:r,getErrorMessage:(e,o)=>{let a=typeof e=="string"?e.length:0;return i({path:o,value:e,code:r,max:n,actual:a})},params:[n,t]}}});0&&(module.exports={stringMaxPlugin});

package/dist/plugins/stringMax.mjs

@@ -0,0 +1 @@
+var T=(a,o,i,s)=>{let t=(n=>(...r)=>{let m=n(...r);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(i);switch(a){case"conditional":return(n,...r)=>t(n,...r);case"fieldReference":return(n,...r)=>t(n,...r);case"multiFieldReference":return t;case"transform":return n=>t(n);case"arrayElement":return(n,...r)=>t(n,...r);case"context":return n=>t(n);default:return t}};function l(a){let{name:o,methodName:i,allowedTypes:s,category:e,impl:t}=a;return{name:o,methodName:i,allowedTypes:s,category:e,create:()=>T(e,i,t,o)}}var p="stringMax",u=["string"],y=l({name:"stringMax",methodName:"max",allowedTypes:u,category:"standard",impl:(a,o)=>{let i=o?.code||p,s=o?.messageFactory||(e=>`String must have at most ${e.max} characters, but got ${e.actual}`);if(typeof a!="number"||a<0)throw new Error(`Invalid maxLength: ${a}`);return{check:e=>typeof e!="string"?!0:e.length<=a,code:i,getErrorMessage:(e,t)=>{let n=typeof e=="string"?e.length:0;return s({path:t,value:e,code:i,max:a,actual:n})},params:[a,o]}}});export{y as stringMaxPlugin};

package/dist/plugins/stringMin.d.ts

@@ -0,0 +1,43 @@
+import { ValidationOptions, MessageContext } from "../core/plugin/types";
+export interface StringMinContext extends MessageContext {
+    min: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name stringMin
+ * @category standard
+ * @description Validates that a string has at least the specified minimum length
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * // Basic usage - set minimum string length
+ * const validator = Builder()
+ *   .use(stringMinPlugin)
+ *   .for<UserProfile>()
+ *   .v("password", (b) => b.string.min(8))
+ *   .v("username", (b) => b.string.min(3))
+ *   .build();
+ *
+ * // Combined with other validators
+ * builder.v("bio", b => b.string.required().min(10).max(500))
+ * ```
+ * @params
+ * - min: number - Minimum character count
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if string length is at least the minimum
+ * @customError
+ * ```typescript
+ * .min(8, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be at least ${params.min} characters (current: ${value.length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringMinPlugin: import("../index").TypedPlugin<"stringMin", "min", (minLength: number, options?: ValidationOptions<StringMinContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => any;
+    params: (number | ValidationOptions<StringMinContext>)[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringMin.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(n,t)=>{for(var r in t)l(n,r,{get:t[r],enumerable:!0})},y=(n,t,r,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of p(t))!g.call(n,e)&&e!==r&&l(n,e,{get:()=>t[e],enumerable:!(s=T(t,e))||s.enumerable});return n};var c=n=>y(l({},"__esModule",{value:!0}),n);var P={};d(P,{stringMinPlugin:()=>I});module.exports=c(P);var f=(n,t,r,s)=>{let i=(a=>(...o)=>{let m=a(...o);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(r);switch(n){case"conditional":return(a,...o)=>i(a,...o);case"fieldReference":return(a,...o)=>i(a,...o);case"multiFieldReference":return i;case"transform":return a=>i(a);case"arrayElement":return(a,...o)=>i(a,...o);case"context":return a=>i(a);default:return i}};function u(n){let{name:t,methodName:r,allowedTypes:s,category:e,impl:i}=n;return{name:t,methodName:r,allowedTypes:s,category:e,create:()=>f(e,r,i,t)}}var N="string",x="stringMin",h=[N],I=u({name:"stringMin",methodName:"min",allowedTypes:h,category:"standard",impl:(n,t)=>{let r=t?.code||x,s=t?.messageFactory||(e=>`String must have at least ${e.min} characters, but got ${e.actual}`);return{check:e=>typeof e!="string"?!0:e.length>=n,code:r,getErrorMessage:(e,i)=>{let a=typeof e=="string"?e.length:0;if(typeof s=="function"){let o=s;return o.length===0?o():o.length===2?o(r,{path:i,value:e,min:n,actual:a}):o({path:i,value:e,code:r,min:n,actual:a})}return`String must have at least ${n} characters, but got ${a}`},params:[n,t]}}});0&&(module.exports={stringMinPlugin});