@maroonedog/luq 0.1.0-alpha

package/dist/plugins/stringContentEncoding.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @luq-plugin
+ * @name stringContentEncoding
+ * @category string
+ * @description Validates string content encoding (base64, base32, binary, etc.)
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringContentEncodingPlugin)
+ *   .for<{ data: string }>()
+ *   .v("data", (b) => b.string.contentEncoding("base64"))
+ *   .build();
+ *
+ * // Valid for base64: SGVsbG8gV29ybGQ=
+ * // Valid for base32: JBSWY3DPEBLW64TMMQ======
+ * // Valid for binary: 01001000 01100101
+ * ```
+ * @params
+ * - encoding: "base64" | "base32" | "binary" | "7bit" | "8bit" | "quoted-printable"
+ * - options?: { messageFactory?: (context: MessageContext) => string }
+ * @returns Validation function that checks content encoding
+ * @customError
+ * ```typescript
+ * .contentEncoding("base64", {
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid base64 encoded content (received: ${value.substring(0, 20)}...)`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringContentEncodingPlugin: import("../index").TypedPlugin<"stringContentEncoding", "contentEncoding", (encoding: "base64" | "base32" | "binary" | "7bit" | "8bit" | "quoted-printable" | string, options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    messageFactory: (context: MessageContext) => string;
+    params: (string | {
+        messageFactory?: (context: MessageContext) => string;
+    })[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringContentEncoding.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var d=(e,n)=>{for(var r in n)l(e,r,{get:n[r],enumerable:!0})},c=(e,n,r,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let t of T(n))!p.call(e,t)&&t!==r&&l(e,t,{get:()=>n[t],enumerable:!(a=g(n,t))||a.enumerable});return e};var y=e=>c(l({},"__esModule",{value:!0}),e);var w={};d(w,{stringContentEncodingPlugin:()=>E});module.exports=y(w);var f=(e,n,r,a)=>{let o=(s=>(...i)=>{let m=s(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:a}:m})(r);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 u(e){let{name:n,methodName:r,allowedTypes:a,category:t,impl:o}=e;return{name:n,methodName:r,allowedTypes:a,category:t,create:()=>f(t,r,o,n)}}var N=/^[A-Za-z0-9+/]*={0,2}$/,h=/^[A-Z2-7]*={0,6}$/,x=/^[01\s]*$/;function I(e){for(let n=0;n<e.length;n++)if(e.charCodeAt(n)>127)return!1;return!0}function P(e){return!0}function C(e){let n=e.split(/\r?\n/);for(let r of n){if(r.length>76)return!1;let a=0;for(;a<r.length;)if(r[a]==="="){if(a===r.length-1)break;if(a+2<r.length){let t=r.substring(a+1,a+3);if(!/^[0-9A-Fa-f]{2}$/.test(t))return!1;a+=3}else return!1}else a++}return!0}function b(e,n){switch(n.toLowerCase()){case"base64":return e===""?!0:e.length%4!==0?!1:N.test(e);case"base32":return e===""?!0:e.length%8!==0?!1:h.test(e);case"binary":return x.test(e);case"7bit":return I(e);case"8bit":return P(e);case"quoted-printable":return C(e);default:return!0}}var E=u({name:"stringContentEncoding",methodName:"contentEncoding",allowedTypes:["string"],category:"standard",impl:(e,n)=>({check:t=>typeof t!="string"?!1:b(t,e),code:"CONTENT_ENCODING",getErrorMessage:(t,o)=>{let s={path:o,value:t,code:"CONTENT_ENCODING"};return n?.messageFactory?.(s)||`${o} must be valid ${e} encoded content`},messageFactory:t=>n?.messageFactory?.(t)||`${t.path} must be valid ${e} encoded content`,params:[e,n]})});0&&(module.exports={stringContentEncodingPlugin});

package/dist/plugins/stringContentEncoding.mjs

@@ -0,0 +1 @@
+var u=(e,n,s,t)=>{let o=(a=>(...i)=>{let m=a(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:t}:m})(s);switch(e){case"conditional":return(a,...i)=>o(a,...i);case"fieldReference":return(a,...i)=>o(a,...i);case"multiFieldReference":return o;case"transform":return a=>o(a);case"arrayElement":return(a,...i)=>o(a,...i);case"context":return a=>o(a);default:return o}};function l(e){let{name:n,methodName:s,allowedTypes:t,category:r,impl:o}=e;return{name:n,methodName:s,allowedTypes:t,category:r,create:()=>u(r,s,o,n)}}var g=/^[A-Za-z0-9+/]*={0,2}$/,T=/^[A-Z2-7]*={0,6}$/,p=/^[01\s]*$/;function d(e){for(let n=0;n<e.length;n++)if(e.charCodeAt(n)>127)return!1;return!0}function c(e){return!0}function y(e){let n=e.split(/\r?\n/);for(let s of n){if(s.length>76)return!1;let t=0;for(;t<s.length;)if(s[t]==="="){if(t===s.length-1)break;if(t+2<s.length){let r=s.substring(t+1,t+3);if(!/^[0-9A-Fa-f]{2}$/.test(r))return!1;t+=3}else return!1}else t++}return!0}function f(e,n){switch(n.toLowerCase()){case"base64":return e===""?!0:e.length%4!==0?!1:g.test(e);case"base32":return e===""?!0:e.length%8!==0?!1:T.test(e);case"binary":return p.test(e);case"7bit":return d(e);case"8bit":return c(e);case"quoted-printable":return y(e);default:return!0}}var x=l({name:"stringContentEncoding",methodName:"contentEncoding",allowedTypes:["string"],category:"standard",impl:(e,n)=>({check:r=>typeof r!="string"?!1:f(r,e),code:"CONTENT_ENCODING",getErrorMessage:(r,o)=>{let a={path:o,value:r,code:"CONTENT_ENCODING"};return n?.messageFactory?.(a)||`${o} must be valid ${e} encoded content`},messageFactory:r=>n?.messageFactory?.(r)||`${r.path} must be valid ${e} encoded content`,params:[e,n]})});export{x as stringContentEncodingPlugin};

package/dist/plugins/stringContentMediaType.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @luq-plugin
+ * @name stringContentMediaType
+ * @category string
+ * @description Validates that a string's decoded content matches the specified media type
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringContentMediaTypePlugin)
+ *   .for<{ data: string }>()
+ *   .v("data", (b) => b.string.contentMediaType("application/json"))
+ *   .build();
+ *
+ * // Valid: base64-encoded JSON
+ * validator.validate({ data: "eyJrZXkiOiJ2YWx1ZSJ9" }); // {"key":"value"}
+ *
+ * // Invalid: not valid JSON when decoded
+ * validator.validate({ data: "aGVsbG8gd29ybGQ=" }); // "hello world"
+ * ```
+ * @params
+ * - mediaType: string - The expected media type
+ * - options?: { encoding?: string; messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that checks content media type
+ * @customError
+ * ```typescript
+ * .contentMediaType("application/json", {
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must contain valid JSON content (received: ${value.substring(0, 20)}...)`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringContentMediaTypePlugin: import("../index").TypedPlugin<"stringContentMediaType", "contentMediaType", (mediaType: string, options?: {
+    encoding?: string;
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    messageFactory: (context: MessageContext) => string;
+    params: (string | {
+        encoding?: string;
+        messageFactory?: (context: MessageContext) => string;
+    })[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringContentMediaType.js

@@ -0,0 +1 @@
+"use strict";var u=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var c=(e,t)=>{for(var r in t)u(e,r,{get:t[r],enumerable:!0})},f=(e,t,r,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of d(t))!T.call(e,n)&&n!==r&&u(e,n,{get:()=>t[n],enumerable:!(s=p(t,n))||s.enumerable});return e};var y=e=>f(u({},"__esModule",{value:!0}),e);var C={};c(C,{stringContentMediaTypePlugin:()=>I});module.exports=y(C);var x=(e,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(e){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 g(e){let{name:t,methodName:r,allowedTypes:s,category:n,impl:i}=e;return{name:t,methodName:r,allowedTypes:s,category:n,create:()=>x(n,r,i,t)}}function h(e,t){try{if(t==="base64"){if(typeof Buffer<"u")return Buffer.from(e,"base64").toString("utf-8");if(typeof atob<"u")return atob(e)}return e}catch{return null}}var l={"application/json":e=>{try{return JSON.parse(e),!0}catch{return!1}},"text/html":e=>/<\/?[a-z][\s\S]*>/i.test(e),"text/xml":e=>/^<\?xml[^>]*\?>|^<[a-zA-Z][\s\S]*>[\s\S]*<\/[a-zA-Z][\s\S]*>$/m.test(e.trim()),"text/plain":()=>!0,"text/css":e=>/[a-zA-Z-]+\s*:\s*[^;]+;?|\.[a-zA-Z-]+\s*\{|#[a-zA-Z-]+\s*\{|[a-zA-Z]+\s*\{/.test(e),"text/javascript":e=>/function\s+\w+\s*\(|const\s+\w+|let\s+\w+|var\s+\w+|=>\s*{|class\s+\w+/.test(e),"application/xml":e=>l["text/xml"](e),"application/pdf":e=>e.startsWith("%PDF"),"image/png":e=>{if(typeof Buffer<"u"){let t=Buffer.from(e,"binary");return t.length>=8&&t[0]===137&&t[1]===80&&t[2]===78&&t[3]===71}return e.charCodeAt(0)===137&&e.charCodeAt(1)===80&&e.charCodeAt(2)===78&&e.charCodeAt(3)===71},"image/jpeg":e=>{if(typeof Buffer<"u"){let t=Buffer.from(e,"binary");return t.length>=3&&t[0]===255&&t[1]===216&&t[2]===255}return e.charCodeAt(0)===255&&e.charCodeAt(1)===216&&e.charCodeAt(2)===255},"image/gif":e=>e.startsWith("GIF87a")||e.startsWith("GIF89a"),"image/svg+xml":e=>/<svg[^>]*>[\s\S]*<\/svg>/i.test(e)};function N(e,t,r){let s=r?h(e,r):e;if(s===null)return!1;let n=l[t.toLowerCase()];return n?n(s):t.startsWith("text/")?!0:t.startsWith("application/")&&t.includes("json")?l["application/json"](s):t.startsWith("application/")&&t.includes("xml")?l["application/xml"](s):!0}var I=g({name:"stringContentMediaType",methodName:"contentMediaType",allowedTypes:["string"],category:"standard",impl:(e,t)=>({check:n=>typeof n!="string"?!1:N(n,e,t?.encoding),code:"CONTENT_MEDIA_TYPE",getErrorMessage:(n,i)=>{let a={path:i,value:n,code:"CONTENT_MEDIA_TYPE"};return t?.messageFactory?.(a)||`${i} must be valid ${e} content${t?.encoding?` (${t.encoding} encoded)`:""}`},messageFactory:n=>t?.messageFactory?.(n)||`${n.path} must be valid ${e} content${t?.encoding?` (${t.encoding} encoded)`:""}`,params:[e,t]})});0&&(module.exports={stringContentMediaTypePlugin});

package/dist/plugins/stringContentMediaType.mjs

@@ -0,0 +1 @@
+var g=(e,t,i,s)=>{let a=(r=>(...o)=>{let m=r(...o);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:s}:m})(i);switch(e){case"conditional":return(r,...o)=>a(r,...o);case"fieldReference":return(r,...o)=>a(r,...o);case"multiFieldReference":return a;case"transform":return r=>a(r);case"arrayElement":return(r,...o)=>a(r,...o);case"context":return r=>a(r);default:return a}};function u(e){let{name:t,methodName:i,allowedTypes:s,category:n,impl:a}=e;return{name:t,methodName:i,allowedTypes:s,category:n,create:()=>g(n,i,a,t)}}function p(e,t){try{if(t==="base64"){if(typeof Buffer<"u")return Buffer.from(e,"base64").toString("utf-8");if(typeof atob<"u")return atob(e)}return e}catch{return null}}var l={"application/json":e=>{try{return JSON.parse(e),!0}catch{return!1}},"text/html":e=>/<\/?[a-z][\s\S]*>/i.test(e),"text/xml":e=>/^<\?xml[^>]*\?>|^<[a-zA-Z][\s\S]*>[\s\S]*<\/[a-zA-Z][\s\S]*>$/m.test(e.trim()),"text/plain":()=>!0,"text/css":e=>/[a-zA-Z-]+\s*:\s*[^;]+;?|\.[a-zA-Z-]+\s*\{|#[a-zA-Z-]+\s*\{|[a-zA-Z]+\s*\{/.test(e),"text/javascript":e=>/function\s+\w+\s*\(|const\s+\w+|let\s+\w+|var\s+\w+|=>\s*{|class\s+\w+/.test(e),"application/xml":e=>l["text/xml"](e),"application/pdf":e=>e.startsWith("%PDF"),"image/png":e=>{if(typeof Buffer<"u"){let t=Buffer.from(e,"binary");return t.length>=8&&t[0]===137&&t[1]===80&&t[2]===78&&t[3]===71}return e.charCodeAt(0)===137&&e.charCodeAt(1)===80&&e.charCodeAt(2)===78&&e.charCodeAt(3)===71},"image/jpeg":e=>{if(typeof Buffer<"u"){let t=Buffer.from(e,"binary");return t.length>=3&&t[0]===255&&t[1]===216&&t[2]===255}return e.charCodeAt(0)===255&&e.charCodeAt(1)===216&&e.charCodeAt(2)===255},"image/gif":e=>e.startsWith("GIF87a")||e.startsWith("GIF89a"),"image/svg+xml":e=>/<svg[^>]*>[\s\S]*<\/svg>/i.test(e)};function d(e,t,i){let s=i?p(e,i):e;if(s===null)return!1;let n=l[t.toLowerCase()];return n?n(s):t.startsWith("text/")?!0:t.startsWith("application/")&&t.includes("json")?l["application/json"](s):t.startsWith("application/")&&t.includes("xml")?l["application/xml"](s):!0}var f=u({name:"stringContentMediaType",methodName:"contentMediaType",allowedTypes:["string"],category:"standard",impl:(e,t)=>({check:n=>typeof n!="string"?!1:d(n,e,t?.encoding),code:"CONTENT_MEDIA_TYPE",getErrorMessage:(n,a)=>{let r={path:a,value:n,code:"CONTENT_MEDIA_TYPE"};return t?.messageFactory?.(r)||`${a} must be valid ${e} content${t?.encoding?` (${t.encoding} encoded)`:""}`},messageFactory:n=>t?.messageFactory?.(n)||`${n.path} must be valid ${e} content${t?.encoding?` (${t.encoding} encoded)`:""}`,params:[e,t]})});export{f as stringContentMediaTypePlugin};

package/dist/plugins/stringDate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @luq-plugin
+ * @name stringDate
+ * @category string
+ * @description Validates ISO 8601 date format (YYYY-MM-DD)
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringDatePlugin)
+ *   .for<{ birthDate: string }>()
+ *   .v("birthDate", (b) => b.string.date())
+ *   .build();
+ *
+ * // Valid formats:
+ * // 2024-01-15
+ * // 2024-12-31
+ * // 2000-02-29 (leap year)
+ *
+ * // Invalid:
+ * // 2024-13-01 (invalid month)
+ * // 2024-02-30 (invalid day)
+ * // 2024-1-1 (must be zero-padded)
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that checks ISO 8601 date format
+ * @customError
+ * ```typescript
+ * .date({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a valid ISO 8601 date format (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringDatePlugin: import("../index").TypedPlugin<"stringDate", "date", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    messageFactory: (context: MessageContext) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringDate.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var y=(e,n)=>{for(var o in n)l(e,o,{get:n[o],enumerable:!0})},c=(e,n,o,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let s of d(n))!g.call(e,s)&&s!==o&&l(e,s,{get:()=>n[s],enumerable:!(t=u(n,s))||t.enumerable});return e};var f=e=>c(l({},"__esModule",{value:!0}),e);var P={};y(P,{stringDatePlugin:()=>x});module.exports=f(P);var N=(e,n,o,t)=>{let a=(r=>(...i)=>{let m=r(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:t}:m})(o);switch(e){case"conditional":return(r,...i)=>a(r,...i);case"fieldReference":return(r,...i)=>a(r,...i);case"multiFieldReference":return a;case"transform":return r=>a(r);case"arrayElement":return(r,...i)=>a(r,...i);case"context":return r=>a(r);default:return a}};function p(e){let{name:n,methodName:o,allowedTypes:t,category:s,impl:a}=e;return{name:n,methodName:o,allowedTypes:t,category:s,create:()=>N(s,o,a,n)}}var h=/^(\d{4})-(\d{2})-(\d{2})$/;function I(e){let n=e.match(h);if(!n)return!1;let[,o,t,s]=n,a=parseInt(o,10),r=parseInt(t,10),i=parseInt(s,10);if(r<1||r>12||i<1||i>31)return!1;let m=[31,28,31,30,31,30,31,31,30,31,30,31];if((a%4===0&&a%100!==0||a%400===0)&&(m[1]=29),i>m[r-1])return!1;let T=new Date(`${e}T12:00:00Z`);return isNaN(T.getTime())?!1:T.toISOString().split("T")[0]===e}var x=p({name:"stringDate",methodName:"date",allowedTypes:["string"],category:"standard",impl:e=>({check:t=>typeof t!="string"?!1:I(t),code:"FORMAT_DATE",getErrorMessage:(t,s)=>{let a={path:s,value:t,code:"FORMAT_DATE"};return e?.messageFactory?.(a)||`${s} must be a valid ISO 8601 date (YYYY-MM-DD)`},messageFactory:t=>e?.messageFactory?.(t)||`${t.path} must be a valid ISO 8601 date (YYYY-MM-DD)`,params:[e]})});0&&(module.exports={stringDatePlugin});

package/dist/plugins/stringDate.mjs

@@ -0,0 +1 @@
+var p=(a,i,m,t)=>{let e=(n=>(...r)=>{let o=n(...r);return o&&typeof o=="object"&&"check"in o?{...o,pluginName:t}:o})(m);switch(a){case"conditional":return(n,...r)=>e(n,...r);case"fieldReference":return(n,...r)=>e(n,...r);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...r)=>e(n,...r);case"context":return n=>e(n);default:return e}};function T(a){let{name:i,methodName:m,allowedTypes:t,category:s,impl:e}=a;return{name:i,methodName:m,allowedTypes:t,category:s,create:()=>p(s,m,e,i)}}var u=/^(\d{4})-(\d{2})-(\d{2})$/;function d(a){let i=a.match(u);if(!i)return!1;let[,m,t,s]=i,e=parseInt(m,10),n=parseInt(t,10),r=parseInt(s,10);if(n<1||n>12||r<1||r>31)return!1;let o=[31,28,31,30,31,30,31,31,30,31,30,31];if((e%4===0&&e%100!==0||e%400===0)&&(o[1]=29),r>o[n-1])return!1;let l=new Date(`${a}T12:00:00Z`);return isNaN(l.getTime())?!1:l.toISOString().split("T")[0]===a}var N=T({name:"stringDate",methodName:"date",allowedTypes:["string"],category:"standard",impl:a=>({check:t=>typeof t!="string"?!1:d(t),code:"FORMAT_DATE",getErrorMessage:(t,s)=>{let e={path:s,value:t,code:"FORMAT_DATE"};return a?.messageFactory?.(e)||`${s} must be a valid ISO 8601 date (YYYY-MM-DD)`},messageFactory:t=>a?.messageFactory?.(t)||`${t.path} must be a valid ISO 8601 date (YYYY-MM-DD)`,params:[a]})});export{N as stringDatePlugin};

package/dist/plugins/stringDatetime.d.ts

@@ -0,0 +1,108 @@
+import type { MessageContext } from "../core/plugin/types";
+/**
+ * @luq-plugin
+ * @name stringDatetime
+ * @category string
+ * @description Validates ISO 8601 datetime format with optional timezone support
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc3339 - RFC 3339: Date and Time on the Internet: Timestamps
+ * @see https://en.wikipedia.org/wiki/ISO_8601 - ISO 8601 Date and Time Format
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date - MDN Date Object
+ * @example
+ * ```typescript
+ * // Basic usage - validates ISO 8601 datetime format (RFC 3339 compliant)
+ * const validator = Builder()
+ *   .use(stringDatetimePlugin)
+ *   .for<{ timestamp: string }>()
+ *   .v("timestamp", (b) => b.string.datetime())
+ *   .build();
+ *
+ * // Strict mode - requires timezone
+ * const strictValidator = Builder()
+ *   .use(stringDatetimePlugin)
+ *   .for<{ timestamp: string }>()
+ *   .v("timestamp", (b) => b.string.datetime({ strict: true }))
+ *   .build();
+ *
+ * // ✅ VALID datetime formats (RFC 3339 / ISO 8601)
+ * // UTC timezone
+ * validator.parse({ timestamp: "2024-01-15T10:30:00Z" });           // UTC with Z
+ * validator.parse({ timestamp: "2024-12-31T23:59:59Z" });           // End of year
+ * validator.parse({ timestamp: "2000-01-01T00:00:00Z" });           // Y2K date
+ *
+ * // With timezone offsets
+ * validator.parse({ timestamp: "2024-01-15T10:30:00+09:00" });      // Japan timezone
+ * validator.parse({ timestamp: "2024-01-15T10:30:00-05:00" });      // EST timezone
+ * validator.parse({ timestamp: "2024-01-15T10:30:00+00:00" });      // UTC with offset
+ * validator.parse({ timestamp: "2024-01-15T10:30:00-12:00" });      // Far west timezone
+ * validator.parse({ timestamp: "2024-01-15T10:30:00+14:00" });      // Far east timezone
+ *
+ * // With milliseconds
+ * validator.parse({ timestamp: "2024-01-15T10:30:00.123Z" });       // 3-digit milliseconds
+ * validator.parse({ timestamp: "2024-01-15T10:30:00.1Z" });         // 1-digit milliseconds
+ * validator.parse({ timestamp: "2024-01-15T10:30:00.12Z" });        // 2-digit milliseconds
+ * validator.parse({ timestamp: "2024-01-15T10:30:00.999+09:00" });  // Max milliseconds with offset
+ *
+ * // Leap year dates
+ * validator.parse({ timestamp: "2024-02-29T12:00:00Z" });           // Valid leap day 2024
+ * validator.parse({ timestamp: "2000-02-29T12:00:00Z" });           // Valid leap day 2000
+ *
+ * // Edge cases
+ * validator.parse({ timestamp: "2024-01-01T00:00:00Z" });           // Start of year
+ * validator.parse({ timestamp: "2024-12-31T23:59:59.999Z" });       // End of year with ms
+ * validator.parse({ timestamp: "1970-01-01T00:00:00Z" });           // Unix epoch
+ * validator.parse({ timestamp: "9999-12-31T23:59:59Z" });           // Far future
+ *
+ * // Without timezone (lenient mode only)
+ * validator.parse({ timestamp: "2024-01-15T10:30:00" });            // Local time (strict: false)
+ * validator.parse({ timestamp: "2024-01-15T10:30:00.123" });        // Local time with ms
+ *
+ * // ❌ INVALID datetime formats
+ * validator.parse({ timestamp: "invalid-datetime" });               // Plain text
+ * validator.parse({ timestamp: "2024-13-15T10:30:00Z" });           // Invalid month (13)
+ * validator.parse({ timestamp: "2024-00-15T10:30:00Z" });           // Invalid month (0)
+ * validator.parse({ timestamp: "2024-01-32T10:30:00Z" });           // Invalid day (32)
+ * validator.parse({ timestamp: "2024-01-00T10:30:00Z" });           // Invalid day (0)
+ * validator.parse({ timestamp: "2024-01-15T25:30:00Z" });           // Invalid hour (25)
+ * validator.parse({ timestamp: "2024-01-15T10:60:00Z" });           // Invalid minute (60)
+ * validator.parse({ timestamp: "2024-01-15T10:30:61Z" });           // Invalid second (61)
+ * validator.parse({ timestamp: "2024-02-30T10:30:00Z" });           // Invalid day for February
+ * validator.parse({ timestamp: "2023-02-29T10:30:00Z" });           // Not a leap year
+ * validator.parse({ timestamp: "2024-04-31T10:30:00Z" });           // Invalid day for April
+ * validator.parse({ timestamp: "2024-01-15 10:30:00Z" });           // Space instead of T
+ * validator.parse({ timestamp: "2024/01/15T10:30:00Z" });           // Wrong date separator
+ * validator.parse({ timestamp: "24-01-15T10:30:00Z" });             // 2-digit year
+ * validator.parse({ timestamp: "2024-1-15T10:30:00Z" });            // Single-digit month
+ * validator.parse({ timestamp: "2024-01-5T10:30:00Z" });            // Single-digit day
+ * validator.parse({ timestamp: "2024-01-15T10:30:00" });            // Missing timezone (strict: true)
+ * validator.parse({ timestamp: "2024-01-15T10:30:00+25:00" });      // Invalid timezone offset
+ * validator.parse({ timestamp: "2024-01-15T10:30:00.1234Z" });      // Too many milliseconds digits
+ * validator.parse({ timestamp: "" });                              // Empty string
+ * validator.parse({ timestamp: "2024-01-15T10:30:00Z " });          // Trailing space
+ * validator.parse({ timestamp: " 2024-01-15T10:30:00Z" });          // Leading space
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string; strict?: boolean } - Optional configuration
+ * @returns Validation function that checks ISO 8601 datetime format
+ * @customError
+ * ```typescript
+ * .datetime({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a valid ISO 8601 datetime (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringDatetimePlugin: import("../index").TypedPlugin<"stringDatetime", "datetime", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+    strict?: boolean;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    messageFactory: (context: MessageContext) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+        strict?: boolean;
+    }[];
+}, readonly ["string"], "validator", "standard">;

package/dist/plugins/stringDatetime.js

@@ -0,0 +1 @@
+"use strict";var u=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var P=Object.prototype.hasOwnProperty;var M=(e,t)=>{for(var o in t)u(e,o,{get:t[o],enumerable:!0})},C=(e,t,o,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of x(t))!P.call(e,a)&&a!==o&&u(e,a,{get:()=>t[a],enumerable:!(n=h(t,a))||n.enumerable});return e};var E=e=>C(u({},"__esModule",{value:!0}),e);var k={};M(k,{stringDatetimePlugin:()=>W});module.exports=E(k);var w=(e,t,o,n)=>{let r=(s=>(...i)=>{let m=s(...i);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:n}:m})(o);switch(e){case"conditional":return(s,...i)=>r(s,...i);case"fieldReference":return(s,...i)=>r(s,...i);case"multiFieldReference":return r;case"transform":return s=>r(s);case"arrayElement":return(s,...i)=>r(s,...i);case"context":return s=>r(s);default:return r}};function f(e){let{name:t,methodName:o,allowedTypes:n,category:a,impl:r}=e;return{name:t,methodName:o,allowedTypes:n,category:a,create:()=>w(a,o,r,t)}}var S=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/,b=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})?$/;function O(e,t=!1){let o=t?S:b,n=e.match(o);if(!n)return!1;let[,a,r,s,i,m,I]=n,l=parseInt(a,10),T=parseInt(r,10),d=parseInt(s,10),p=parseInt(i,10),g=parseInt(m,10),c=parseInt(I,10);if(T<1||T>12||d<1||d>31||p<0||p>23||g<0||g>59||c<0||c>60)return!1;let y=[31,28,31,30,31,30,31,31,30,31,30,31];if((l%4===0&&l%100!==0||l%400===0)&&(y[1]=29),d>y[T-1])return!1;let N=new Date(e);return!isNaN(N.getTime())}var W=f({name:"stringDatetime",methodName:"datetime",allowedTypes:["string"],category:"standard",impl:e=>({check:n=>typeof n!="string"?!1:O(n,e?.strict),code:"FORMAT_DATETIME",getErrorMessage:(n,a)=>{let r={path:a,value:n,code:"FORMAT_DATETIME"};return e?.messageFactory?.(r)||`${a} must be a valid ISO 8601 datetime`},messageFactory:n=>e?.messageFactory?.(n)||`${n.path} must be a valid ISO 8601 datetime`,params:[e]})});0&&(module.exports={stringDatetimePlugin});

package/dist/plugins/stringDatetime.mjs

@@ -0,0 +1 @@
+var N=(a,m,o,e)=>{let n=(t=>(...r)=>{let i=t(...r);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:e}:i})(o);switch(a){case"conditional":return(t,...r)=>n(t,...r);case"fieldReference":return(t,...r)=>n(t,...r);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...r)=>n(t,...r);case"context":return t=>n(t);default:return n}};function y(a){let{name:m,methodName:o,allowedTypes:e,category:s,impl:n}=a;return{name:m,methodName:o,allowedTypes:e,category:s,create:()=>N(s,o,n,m)}}var h=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/,x=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})?$/;function P(a,m=!1){let o=m?h:x,e=a.match(o);if(!e)return!1;let[,s,n,t,r,i,f]=e,l=parseInt(s,10),T=parseInt(n,10),d=parseInt(t,10),u=parseInt(r,10),p=parseInt(i,10),g=parseInt(f,10);if(T<1||T>12||d<1||d>31||u<0||u>23||p<0||p>59||g<0||g>60)return!1;let c=[31,28,31,30,31,30,31,31,30,31,30,31];if((l%4===0&&l%100!==0||l%400===0)&&(c[1]=29),d>c[T-1])return!1;let I=new Date(a);return!isNaN(I.getTime())}var w=y({name:"stringDatetime",methodName:"datetime",allowedTypes:["string"],category:"standard",impl:a=>({check:e=>typeof e!="string"?!1:P(e,a?.strict),code:"FORMAT_DATETIME",getErrorMessage:(e,s)=>{let n={path:s,value:e,code:"FORMAT_DATETIME"};return a?.messageFactory?.(n)||`${s} must be a valid ISO 8601 datetime`},messageFactory:e=>a?.messageFactory?.(e)||`${e.path} must be a valid ISO 8601 datetime`,params:[a]})});export{w as stringDatetimePlugin};

package/dist/plugins/stringDuration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @luq-plugin
+ * @name stringDuration
+ * @category string
+ * @description Validates ISO 8601 duration format
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringDurationPlugin)
+ *   .for<{ duration: string }>()
+ *   .v("duration", (b) => b.string.duration())
+ *   .build();
+ *
+ * // Valid: P3Y6M4DT12H30M5S (3 years, 6 months, 4 days, 12 hours, 30 minutes, 5 seconds)
+ * // Valid: PT1H30M (1 hour, 30 minutes)
+ * // Valid: P7D (7 days)
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks ISO 8601 duration format
+ * @customError
+ * ```typescript
+ * .duration({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid ISO 8601 duration format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringDurationPlugin: import("../index").TypedPlugin<"stringDuration", "duration", (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/stringDuration.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(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))!d.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={};g(I,{stringDurationPlugin:()=>x});module.exports=c(I);var f=(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:()=>f(r,a,s,e)}}var N=/^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/,x=T({name:"stringDuration",methodName:"duration",allowedTypes:["string"],category:"standard",impl:n=>{let e=()=>"must be a valid ISO 8601 duration",a=n?.messageFactory||(t=>`${t.path} ${e()}`);return{check:t=>typeof t!="string"?!1:N.test(t),code:"FORMAT_DURATION",getErrorMessage:(t,r)=>a({path:r,value:t,code:"FORMAT_DURATION"}),params:[n]}}});0&&(module.exports={stringDurationPlugin});

package/dist/plugins/stringDuration.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=/^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/,g=l({name:"stringDuration",methodName:"duration",allowedTypes:["string"],category:"standard",impl:r=>{let s=()=>"must be a valid ISO 8601 duration",o=r?.messageFactory||(n=>`${n.path} ${s()}`);return{check:n=>typeof n!="string"?!1:p.test(n),code:"FORMAT_DURATION",getErrorMessage:(n,i)=>o({path:i,value:n,code:"FORMAT_DURATION"}),params:[r]}}});export{g as stringDurationPlugin};

package/dist/plugins/stringEmail.d.ts

@@ -0,0 +1,81 @@
+import { ValidationOptions } from "../core/plugin/types";
+interface EmailValidationOptions extends ValidationOptions {
+    allowedDomains?: string[];
+    customRegex?: RegExp;
+}
+/**
+ * @luq-plugin
+ * @name stringEmail
+ * @category standard
+ * @description Simple and fast email validation with domain restriction and custom regex support (RFC 5322 compliant)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc5322 - RFC 5322: Internet Message Format
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email - MDN Email Input Validation
+ * @example
+ * ```typescript
+ * // Basic usage - validates email format (RFC 5322 compliant)
+ * const validator = Builder()
+ *   .use(stringEmailPlugin)
+ *   .for<UserProfile>()
+ *   .v("email", (b) => b.string.email())
+ *   .v("contactEmail", (b) => b.string.required().email())
+ *   .build();
+ *
+ * // Domain restriction (practical: corporate email only)
+ * builder.v("workEmail", b => b.string.required().email({
+ *   allowedDomains: ["company.com", "subsidiary.co.jp"]
+ * }))
+ *
+ * // Custom regex for specific format requirements
+ * builder.v("strictEmail", b => b.string.email({
+ *   customRegex: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+ * }))
+ *
+ * // For length limits, use existing string plugins:
+ * builder.v("email", b => b.string.required().max(100).email())
+ *
+ * // ✅ VALID email formats (RFC 5322)
+ * validator.parse({ email: "user@example.com" });              // Standard format
+ * validator.parse({ email: "test.email+tag@domain.co.uk" });   // With plus and dots
+ * validator.parse({ email: "user123@test-server.com" });       // Numbers and hyphens
+ * validator.parse({ email: "firstname.lastname@example.org" }); // Multiple dots
+ * validator.parse({ email: "user+filter@gmail.com" });         // Plus addressing
+ * validator.parse({ email: "a@b.co" });                        // Minimal valid
+ * validator.parse({ email: "test_email@domain-name.com" });     // Underscores and hyphens
+ *
+ * // ❌ INVALID email formats
+ * validator.parse({ email: "plainaddress" });          // No @ symbol
+ * validator.parse({ email: "@missingdomain.com" });    // Missing local part
+ * validator.parse({ email: "missing.domain@" });       // Missing domain
+ * validator.parse({ email: "spaces @domain.com" });    // Spaces not allowed
+ * validator.parse({ email: "user@.com" });             // Invalid domain start
+ * validator.parse({ email: "user@domain" });           // Missing TLD
+ * validator.parse({ email: "user@@domain.com" });      // Double @ symbol
+ * validator.parse({ email: "user@domain..com" });      // Double dots in domain
+ * validator.parse({ email: ".user@domain.com" });      // Leading dot
+ * validator.parse({ email: "user.@domain.com" });      // Trailing dot
+ * ```
+ * @params
+ * - options?: EmailValidationOptions - Simple email validation configuration
+ *   - allowedDomains?: string[] - Only allow emails from these domains (practical for corporate restrictions)
+ *   - customRegex?: RegExp - Custom regex to override basic validation (practical escape hatch)
+ *   - messageFactory?: (context: MessageContext) => string - Custom error message factory
+ * @returns Validation function optimized for performance - regex validation with optional domain filtering or custom regex
+ * @customError
+ * ```typescript
+ * .email({
+ *   allowedDomains: ["company.com"],
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a company email address (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringEmailPlugin: import("../index").TypedPlugin<"stringEmail", "email", (options?: EmailValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: EmailValidationOptions[];
+    validationOptions: EmailValidationOptions;
+}, readonly ["string"], "validator", "standard">;
+export {};

package/dist/plugins/stringEmail.js

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var c=(n,t)=>{for(var o in t)l(n,o,{get:t[o],enumerable:!0})},f=(n,t,o,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of g(t))!y.call(n,s)&&s!==o&&l(n,s,{get:()=>t[s],enumerable:!(i=u(t,s))||i.enumerable});return n};var x=n=>f(l({},"__esModule",{value:!0}),n);var E={};c(E,{stringEmailPlugin:()=>w});module.exports=x(E);var N=(n,t,o,i)=>{let e=(a=>(...r)=>{let m=a(...r);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:i}:m})(o);switch(n){case"conditional":return(a,...r)=>e(a,...r);case"fieldReference":return(a,...r)=>e(a,...r);case"multiFieldReference":return e;case"transform":return a=>e(a);case"arrayElement":return(a,...r)=>e(a,...r);case"context":return a=>e(a);default:return e}};function d(n){let{name:t,methodName:o,allowedTypes:i,category:s,impl:e}=n;return{name:t,methodName:o,allowedTypes:i,category:s,create:()=>N(s,o,e,t)}}var I=["string"],h=/^[a-zA-Z0-9]([a-zA-Z0-9._%+-]*[a-zA-Z0-9])?@[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/,P="stringEmail",w=d({name:"stringEmail",methodName:"email",allowedTypes:I,category:"standard",impl:n=>{let t=n?.code||P,o=n?.messageFactory||(e=>e.reason?`Invalid email: ${e.reason}`:"Invalid email address"),i=n?.allowedDomains?new Set(n.allowedDomains.map(e=>e.toLowerCase())):null,s=n?.customRegex||h;return{check:e=>{if(typeof e!="string")return!0;if(!s.test(e))return!1;if(i){let a=e.lastIndexOf("@");if(a===-1)return!1;let r=e.substring(a+1).toLowerCase();return i.has(r)}return!0},code:t,getErrorMessage:(e,a)=>{if(typeof e!="string")return o({path:a,value:e,code:t});let r="";if(!s.test(e))r="invalid format";else if(i){let T=e.lastIndexOf("@");if(T!==-1){let p=e.substring(T+1).toLowerCase();i.has(p)||(r=`domain not allowed (allowed: ${Array.from(i).join(", ")})`)}}return o({path:a,value:e,code:t,reason:r})},params:n?[n]:[],validationOptions:n}}});0&&(module.exports={stringEmailPlugin});

package/dist/plugins/stringEmail.mjs

@@ -0,0 +1 @@
+var p=(a,o,i,r)=>{let e=(n=>(...t)=>{let m=n(...t);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:r}:m})(i);switch(a){case"conditional":return(n,...t)=>e(n,...t);case"fieldReference":return(n,...t)=>e(n,...t);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...t)=>e(n,...t);case"context":return n=>e(n);default:return e}};function T(a){let{name:o,methodName:i,allowedTypes:r,category:s,impl:e}=a;return{name:o,methodName:i,allowedTypes:r,category:s,create:()=>p(s,i,e,o)}}var u=["string"],g=/^[a-zA-Z0-9]([a-zA-Z0-9._%+-]*[a-zA-Z0-9])?@[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/,y="stringEmail",x=T({name:"stringEmail",methodName:"email",allowedTypes:u,category:"standard",impl:a=>{let o=a?.code||y,i=a?.messageFactory||(e=>e.reason?`Invalid email: ${e.reason}`:"Invalid email address"),r=a?.allowedDomains?new Set(a.allowedDomains.map(e=>e.toLowerCase())):null,s=a?.customRegex||g;return{check:e=>{if(typeof e!="string")return!0;if(!s.test(e))return!1;if(r){let n=e.lastIndexOf("@");if(n===-1)return!1;let t=e.substring(n+1).toLowerCase();return r.has(t)}return!0},code:o,getErrorMessage:(e,n)=>{if(typeof e!="string")return i({path:n,value:e,code:o});let t="";if(!s.test(e))t="invalid format";else if(r){let l=e.lastIndexOf("@");if(l!==-1){let d=e.substring(l+1).toLowerCase();r.has(d)||(t=`domain not allowed (allowed: ${Array.from(r).join(", ")})`)}}return i({path:n,value:e,code:o,reason:t})},params:a?[a]:[],validationOptions:a}}});export{x as stringEmailPlugin};

package/dist/plugins/stringHostname.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @luq-plugin
+ * @name stringHostname
+ * @category string
+ * @description Validates hostname format (RFC 1123)
+ * @allowedTypes ["string"]
+ * @see https://tools.ietf.org/html/rfc1123 - RFC 1123: Requirements for Internet Hosts - Application and Support
+ * @see https://tools.ietf.org/html/rfc952 - RFC 952: DoD Internet Host Table Specification
+ * @see https://en.wikipedia.org/wiki/Hostname - Hostname Format Reference
+ * @example
+ * ```typescript
+ * // Basic usage - validates hostname format (RFC 1123 compliant)
+ * const validator = Builder()
+ *   .use(stringHostnamePlugin)
+ *   .for<{ hostname: string }>()
+ *   .v("hostname", (b) => b.string.hostname())
+ *   .build();
+ *
+ * // ✅ VALID hostnames (RFC 1123)
+ * validator.parse({ hostname: "example.com" });                 // Standard domain
+ * validator.parse({ hostname: "www.example.com" });             // Subdomain
+ * validator.parse({ hostname: "mail-server.company.org" });     // With hyphens
+ * validator.parse({ hostname: "a.b.c" });                      // Short labels
+ * validator.parse({ hostname: "host123.domain.co.uk" });        // With numbers
+ * validator.parse({ hostname: "localhost" });                  // Single label
+ * validator.parse({ hostname: "api-v2.service.internal" });     // Multiple hyphens
+ * validator.parse({ hostname: "test" });                       // Single word
+ * validator.parse({ hostname: "1a.2b.3c" });                   // Starting with numbers
+ * validator.parse({ hostname: "x" });                          // Single character
+ * validator.parse({ hostname: "sub.domain.example.com" });      // Multiple levels
+ * validator.parse({ hostname: "ftp.files.company-name.org" });  // Complex structure
+ * validator.parse({ hostname: "db1.cluster.production" });      // Database naming
+ * validator.parse({ hostname: "web01.dmz.corp" });             // Network zones
+ * validator.parse({ hostname: "backup-server.it.department" }); // Organizational
+ *
+ * // Edge cases
+ * validator.parse({ hostname: "a".repeat(63) });               // Max label length (63 chars)
+ * validator.parse({ hostname: "a".repeat(63) + "." + "b".repeat(63) }); // Multiple max labels
+ * validator.parse({ hostname: "0" });                          // Single digit
+ * validator.parse({ hostname: "9a" });                         // Number followed by letter
+ *
+ * // ❌ INVALID hostnames
+ * validator.parse({ hostname: "-example.com" });               // Starting with hyphen
+ * validator.parse({ hostname: "example-.com" });               // Label ending with hyphen
+ * validator.parse({ hostname: "example.com-" });               // Hostname ending with hyphen
+ * validator.parse({ hostname: ".example.com" });               // Starting with dot
+ * validator.parse({ hostname: "example..com" });               // Double dot (empty label)
+ * validator.parse({ hostname: "example.com." });               // Trailing dot
+ * validator.parse({ hostname: "" });                          // Empty string
+ * validator.parse({ hostname: "example .com" });               // Space in hostname
+ * validator.parse({ hostname: "example_com" });                // Underscore not allowed
+ * validator.parse({ hostname: "EXAMPLE.COM" });                // All caps (valid but not recommended)
+ * validator.parse({ hostname: "example.com/path" });           // With path
+ * validator.parse({ hostname: "example.com:8080" });           // With port
+ * validator.parse({ hostname: "user@example.com" });           // With user
+ * validator.parse({ hostname: "http://example.com" });         // Full URL
+ * validator.parse({ hostname: "192.168.1.1" });               // IP address (not hostname)
+ * validator.parse({ hostname: "[::1]" });                     // IPv6 address
+ *
+ * // Label too long (> 63 characters)
+ * validator.parse({ hostname: "a".repeat(64) + ".com" });      // Single label > 63 chars
+ *
+ * // Hostname too long (> 253 characters total)
+ * const longLabel = "a".repeat(50);
+ * const longHostname = Array(10).fill(longLabel).join(".") + ".com"; // > 253 chars total
+ * validator.parse({ hostname: longHostname });
+ *
+ * // Special characters not allowed
+ * validator.parse({ hostname: "exam@ple.com" });               // @ symbol
+ * validator.parse({ hostname: "exam#ple.com" });               // # symbol
+ * validator.parse({ hostname: "exam$ple.com" });               // $ symbol
+ * validator.parse({ hostname: "exam%ple.com" });               // % symbol
+ * validator.parse({ hostname: "exam&ple.com" });               // & symbol
+ * validator.parse({ hostname: "example.com!" });               // Exclamation mark
+ * validator.parse({ hostname: "example.com?" });               // Question mark
+ *
+ * // Unicode/international domain names (IDN not supported in basic hostname)
+ * validator.parse({ hostname: "ドメイン.com" });                // Japanese characters
+ * validator.parse({ hostname: "münchen.de" });                // German umlaut
+ * validator.parse({ hostname: "café.fr" });                   // French accent
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks hostname format
+ * @customError
+ * ```typescript
+ * .hostname({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid hostname format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "../core/plugin/types";
+export declare const stringHostnamePlugin: import("../index").TypedPlugin<"stringHostname", "hostname", (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/stringHostname.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 x={};d(x,{stringHostnamePlugin:()=>h});module.exports=c(x);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=/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$/,h=T({name:"stringHostname",methodName:"hostname",allowedTypes:["string"],category:"standard",impl:n=>{let e=()=>"must be a valid hostname",a=n?.messageFactory||(t=>`${t.path} ${e()}`);return{check:t=>typeof t!="string"||t.length>253?!1:N.test(t),code:"FORMAT_HOSTNAME",getErrorMessage:(t,r)=>a({path:r,value:t,code:"FORMAT_HOSTNAME"}),params:[n]}}});0&&(module.exports={stringHostnamePlugin});

package/dist/plugins/stringHostname.mjs

@@ -0,0 +1 @@
+var T=(r,s,o,e)=>{let t=(n=>(...a)=>{let i=n(...a);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:e}:i})(o);switch(r){case"conditional":return(n,...a)=>t(n,...a);case"fieldReference":return(n,...a)=>t(n,...a);case"multiFieldReference":return t;case"transform":return n=>t(n);case"arrayElement":return(n,...a)=>t(n,...a);case"context":return n=>t(n);default:return t}};function l(r){let{name:s,methodName:o,allowedTypes:e,category:m,impl:t}=r;return{name:s,methodName:o,allowedTypes:e,category:m,create:()=>T(m,o,t,s)}}var p=/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$/,d=l({name:"stringHostname",methodName:"hostname",allowedTypes:["string"],category:"standard",impl:r=>{let s=()=>"must be a valid hostname",o=r?.messageFactory||(e=>`${e.path} ${s()}`);return{check:e=>typeof e!="string"||e.length>253?!1:p.test(e),code:"FORMAT_HOSTNAME",getErrorMessage:(e,m)=>o({path:m,value:e,code:"FORMAT_HOSTNAME"}),params:[r]}}});export{d as stringHostnamePlugin};