@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/plugins/stringIpv6.d.ts

@@ -1,104 +1 @@
-/**
- * @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">;
+export * from "./string-ipv6/index";

package/dist/plugins/stringIpv6.js

@@ -1 +1,2 @@
-"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});
+"use strict";
+module.exports = require("./string-ipv6/index");

package/dist/plugins/stringIpv6.mjs

@@ -1 +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};
+export * from "./string-ipv6/index.mjs";

package/dist/plugins/stringIri.d.ts

@@ -1,117 +1 @@
-/**
- * @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">;
+export * from "./string-iri/index";

package/dist/plugins/stringIri.js

@@ -1 +1,2 @@
-"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});
+"use strict";
+module.exports = require("./string-iri/index");

package/dist/plugins/stringIri.mjs

@@ -1 +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};
+export * from "./string-iri/index.mjs";

package/dist/plugins/stringIriReference.d.ts

@@ -1,43 +1 @@
-/**
- * @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">;
+export * from "./string-iri-reference/index";

package/dist/plugins/stringIriReference.js

@@ -1 +1,2 @@
-"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});
+"use strict";
+module.exports = require("./string-iri-reference/index");

package/dist/plugins/stringIriReference.mjs

@@ -1 +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};
+export * from "./string-iri-reference/index.mjs";

package/dist/plugins/stringJsonPointer.d.ts

@@ -1,107 +1 @@
-/**
- * @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">;
+export * from "./string-json-pointer/index";

package/dist/plugins/stringJsonPointer.js

@@ -1 +1,2 @@
-"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});
+"use strict";
+module.exports = require("./string-json-pointer/index");

package/dist/plugins/stringJsonPointer.mjs

@@ -1 +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};
+export * from "./string-json-pointer/index.mjs";

package/dist/plugins/stringMax.d.ts

@@ -1,43 +1 @@
-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">;
+export * from "./string-max/index";

package/dist/plugins/stringMax.js

@@ -1 +1,2 @@
-"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});
+"use strict";
+module.exports = require("./string-max/index");

package/dist/plugins/stringMax.mjs

@@ -1 +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};
+export * from "./string-max/index.mjs";

package/dist/plugins/stringMin.d.ts

@@ -1,43 +1 @@
-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">;
+export * from "./string-min/index";

package/dist/plugins/stringMin.js

@@ -1 +1,2 @@
-"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});
+"use strict";
+module.exports = require("./string-min/index");

package/dist/plugins/stringMin.mjs

@@ -1 +1 @@
-var u=(r,i,o,s)=>{let a=(e=>(...t)=>{let m=e(...t);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(o);switch(r){case"conditional":return(e,...t)=>a(e,...t);case"fieldReference":return(e,...t)=>a(e,...t);case"multiFieldReference":return a;case"transform":return e=>a(e);case"arrayElement":return(e,...t)=>a(e,...t);case"context":return e=>a(e);default:return a}};function l(r){let{name:i,methodName:o,allowedTypes:s,category:n,impl:a}=r;return{name:i,methodName:o,allowedTypes:s,category:n,create:()=>u(n,o,a,i)}}var T="string",p="stringMin",g=[T],c=l({name:"stringMin",methodName:"min",allowedTypes:g,category:"standard",impl:(r,i)=>{let o=i?.code||p,s=i?.messageFactory||(n=>`String must have at least ${n.min} characters, but got ${n.actual}`);return{check:n=>typeof n!="string"?!0:n.length>=r,code:o,getErrorMessage:(n,a)=>{let e=typeof n=="string"?n.length:0;if(typeof s=="function"){let t=s;return t.length===0?t():t.length===2?t(o,{path:a,value:n,min:r,actual:e}):t({path:a,value:n,code:o,min:r,actual:e})}return`String must have at least ${r} characters, but got ${e}`},params:[r,i]}}});export{c as stringMinPlugin};
+export * from "./string-min/index.mjs";

package/dist/plugins/stringPattern.d.ts

@@ -1,40 +1 @@
-import { ValidationOptions } from "../core/plugin/types";
-/**
- * @luq-plugin
- * @name stringPattern
- * @category standard
- * @description Validates that a string matches a regular expression pattern
- * @allowedTypes ["string"]
- * @example
- * ```typescript
- * // Basic usage - validate against regex pattern
- * const validator = Builder()
- *   .use(stringPatternPlugin)
- *   .for<UserData>()
- *   .v("phone", (b) => b.string.pattern(/^\d{3}-\d{3}-\d{4}$/))
- *   .v("zipCode", (b) => b.string.pattern(/^\d{5}(-\d{4})?$/))
- *   .build();
- *
- * // Common patterns
- * builder.v("hexColor", b => b.string.pattern(/^#[0-9A-Fa-f]{6}$/))
- * builder.v("slug", b => b.string.pattern(/^[a-z0-9-]+$/))
- * ```
- * @params
- * - pattern: RegExp - Regular expression to match against
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string matches the pattern
- * @customError
- * ```typescript
- * .pattern(/^[A-Z]{2}\d{4}$/, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must match pattern ${params.pattern} (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const stringPatternPlugin: import("../index").TypedPlugin<"stringPattern", "pattern", (regex: RegExp | string, options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (string | RegExp | ValidationOptions<{}>)[];
-}, readonly ["string"], "validator", "standard">;
+export * from "./string-pattern/index";

package/dist/plugins/stringPattern.js

@@ -1 +1,2 @@
-"use strict";var l=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var u=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,s)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of u(n))!g.call(e,r)&&r!==a&&l(e,r,{get:()=>n[r],enumerable:!(s=T(n,r))||s.enumerable});return e};var c=e=>y(l({},"__esModule",{value:!0}),e);var h={};d(h,{stringPatternPlugin:()=>I});module.exports=c(h);var f=(e,n,a,s)=>{let o=(t=>(...i)=>{let m=t(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(a);switch(e){case"conditional":return(t,...i)=>o(t,...i);case"fieldReference":return(t,...i)=>o(t,...i);case"multiFieldReference":return o;case"transform":return t=>o(t);case"arrayElement":return(t,...i)=>o(t,...i);case"context":return t=>o(t);default:return o}};function p(e){let{name:n,methodName:a,allowedTypes:s,category:r,impl:o}=e;return{name:n,methodName:a,allowedTypes:s,category:r,create:()=>f(r,a,o,n)}}var N="stringPattern",x=["string"],I=p({name:"stringPattern",methodName:"pattern",allowedTypes:x,category:"standard",impl:(e,n)=>{let a=n?.code||N,s=n?.messageFactory||(t=>"Invalid format"),r=e.toString(),o=typeof e=="string"?new RegExp(e):e;return{check:t=>typeof t!="string"?!0:o.test(t),code:a,getErrorMessage:(t,i)=>s({path:i,value:t,code:a,pattern:r}),params:[e,n]}}});0&&(module.exports={stringPatternPlugin});
+"use strict";
+module.exports = require("./string-pattern/index");

package/dist/plugins/stringPattern.mjs

@@ -1 +1 @@
-var p=(t,r,o,s)=>{let n=(e=>(...a)=>{let i=e(...a);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:s}:i})(o);switch(t){case"conditional":return(e,...a)=>n(e,...a);case"fieldReference":return(e,...a)=>n(e,...a);case"multiFieldReference":return n;case"transform":return e=>n(e);case"arrayElement":return(e,...a)=>n(e,...a);case"context":return e=>n(e);default:return n}};function l(t){let{name:r,methodName:o,allowedTypes:s,category:m,impl:n}=t;return{name:r,methodName:o,allowedTypes:s,category:m,create:()=>p(m,o,n,r)}}var T="stringPattern",u=["string"],y=l({name:"stringPattern",methodName:"pattern",allowedTypes:u,category:"standard",impl:(t,r)=>{let o=r?.code||T,s=r?.messageFactory||(e=>"Invalid format"),m=t.toString(),n=typeof t=="string"?new RegExp(t):t;return{check:e=>typeof e!="string"?!0:n.test(e),code:o,getErrorMessage:(e,a)=>s({path:a,value:e,code:o,pattern:m}),params:[t,r]}}});export{y as stringPatternPlugin};
+export * from "./string-pattern/index.mjs";

package/dist/plugins/stringRegex.d.ts

@@ -0,0 +1 @@
+export * from "./string-regex/index";