@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/plugins/string-url/string-url.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringUrlPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/string-url/string-url.ts
+// `.url(options?)`, and the Draft-07 `uri` format's single home.
+//
+// Parsing is the platform `URL` constructor, never a regex, so there is no
+// second URL grammar in src to drift from this one. `protocols` values carry
+// their colon ("https:"), matching 1.x; omitting it accepts every scheme
+// (mailto:, tel:, ws:, ftp: all pass), which is also 1.x.
+// ===========================================================================
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const types_1 = require("../../types");
+function parseUrl(text) {
+    try {
+        return new URL(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.stringUrlPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "stringUrl",
+    method: "url",
+    slots: ["string"],
+    build: (ctx, options) => {
+        const protocols = options?.protocols;
+        const allowWithoutProtocol = options?.allowWithoutProtocol === true;
+        return (0, create_rule_1.check)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!(0, types_1.isString)(value))
+                    return types_1.PASS;
+                const text = allowWithoutProtocol && !value.includes("://")
+                    ? `https://${value}`
+                    : value;
+                const parsed = parseUrl(text);
+                if (parsed === undefined)
+                    return (0, types_1.fail)({ actual: value });
+                if (protocols !== undefined && !protocols.includes(parsed.protocol)) {
+                    return (0, types_1.fail)({ expected: parsed.protocol, actual: value });
+                }
+                return types_1.PASS;
+            },
+            describe: () => "Invalid URL format",
+            buildMessageContext: (detail) => ({
+                protocol: (0, types_1.isString)(detail.expected) ? detail.expected : "",
+            }),
+        });
+    },
+});

package/dist/plugins/string-url/string-url.mjs

@@ -0,0 +1,52 @@
+// ===========================================================================
+// L7  src/plugins/string-url/string-url.ts
+// `.url(options?)`, and the Draft-07 `uri` format's single home.
+//
+// Parsing is the platform `URL` constructor, never a regex, so there is no
+// second URL grammar in src to drift from this one. `protocols` values carry
+// their colon ("https:"), matching 1.x; omitting it accepts every scheme
+// (mailto:, tel:, ws:, ftp: all pass), which is also 1.x.
+// ===========================================================================
+import { check } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { PASS, fail, isString } from "../../types/index.mjs";
+function parseUrl(text) {
+    try {
+        return new URL(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export const stringUrlPlugin = /*#__PURE__*/ definePlugin()({
+    name: "stringUrl",
+    method: "url",
+    slots: ["string"],
+    build: (ctx, options) => {
+        const protocols = options?.protocols;
+        const allowWithoutProtocol = options?.allowWithoutProtocol === true;
+        return check({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            run: (value) => {
+                if (!isString(value))
+                    return PASS;
+                const text = allowWithoutProtocol && !value.includes("://")
+                    ? `https://${value}`
+                    : value;
+                const parsed = parseUrl(text);
+                if (parsed === undefined)
+                    return fail({ actual: value });
+                if (protocols !== undefined && !protocols.includes(parsed.protocol)) {
+                    return fail({ expected: parsed.protocol, actual: value });
+                }
+                return PASS;
+            },
+            describe: () => "Invalid URL format",
+            buildMessageContext: (detail) => ({
+                protocol: isString(detail.expected) ? detail.expected : "",
+            }),
+        });
+    },
+});

package/dist/plugins/stringAlphanumeric.d.ts

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

package/dist/plugins/stringAlphanumeric.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./string-alphanumeric/index");

package/dist/plugins/stringAlphanumeric.mjs

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

package/dist/plugins/stringBase64.d.ts

@@ -1,119 +1 @@
-/**
- * @luq-plugin
- * @name stringBase64
- * @category string
- * @description Validates base64 encoded string
- * @allowedTypes ["string"]
- * @see https://tools.ietf.org/html/rfc4648 - RFC 4648: The Base16, Base32, and Base64 Data Encodings
- * @see https://developer.mozilla.org/en-US/docs/Glossary/Base64 - MDN Base64 Encoding Reference
- * @see https://developer.mozilla.org/en-US/docs/Web/API/btoa - MDN btoa() Function
- * @example
- * ```typescript
- * // Basic usage - validates base64 encoded string (RFC 4648 compliant)
- * const validator = Builder()
- *   .use(stringBase64Plugin)
- *   .for<{ encodedData: string }>()
- *   .v("encodedData", (b) => b.string.base64())
- *   .build();
- *
- * // URL-safe base64 validation
- * const urlSafeValidator = Builder()
- *   .use(stringBase64Plugin)
- *   .for<{ token: string }>()
- *   .v("token", (b) => b.string.base64({ urlSafe: true }))
- *   .build();
- *
- * // ✅ VALID base64 strings (RFC 4648)
- * // Standard base64 encoding
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=" });           // "Hello World"
- * validator.parse({ encodedData: "YW55IGNhcm5hbCBwbGVhc3VyZS4=" }); // "any carnal pleasure."
- * validator.parse({ encodedData: "" });                          // Empty string
- * validator.parse({ encodedData: "YQ==" });                      // Single char "a"
- * validator.parse({ encodedData: "YWI=" });                      // Two chars "ab"
- * validator.parse({ encodedData: "YWJj" });                      // Three chars "abc"
- * validator.parse({ encodedData: "YWJjZA==" });                  // Four chars "abcd"
- * validator.parse({ encodedData: "VGhpcyBpcyBhIHRlc3Q=" });       // "This is a test"
- *
- * // With numbers and special base64 characters
- * validator.parse({ encodedData: "MTIzNDU2Nzg5MA==" });          // "1234567890"
- * validator.parse({ encodedData: "QUJDREVGRw==" });              // "ABCDEFG"
- * validator.parse({ encodedData: "YWJjZGVmZ2hpams=" });           // "abcdefghijk"
- * validator.parse({ encodedData: "Pz8/Pz8/Pz8=" });              // Contains + and / chars
- * validator.parse({ encodedData: "+/+/+/+/+/+=" });              // All special chars
- *
- * // Different padding scenarios
- * validator.parse({ encodedData: "YWI=" });                      // One padding char
- * validator.parse({ encodedData: "YQ==" });                      // Two padding chars
- * validator.parse({ encodedData: "YWJj" });                      // No padding needed
- * validator.parse({ encodedData: "YWJjZA==" });                  // Two padding chars
- *
- * // URL-safe base64 (RFC 4648 Section 5)
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ" });          // URL-safe without padding
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ=" });         // URL-safe with padding
- * urlSafeValidator.parse({ token: "YW55IGNhcm5hbC1wbGVhc3VyZS4" }); // Uses - instead of /
- * urlSafeValidator.parse({ token: "YWJjZGVmZ2hpams_" });         // Uses _ instead of +
- * urlSafeValidator.parse({ token: "-_-_-_-_-_-_" });            // All URL-safe special chars
- *
- * // Real-world examples
- * validator.parse({ encodedData: "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9" }); // JWT header
- * validator.parse({ encodedData: "VG8gYmUgb3Igbm90IHRvIGJlLCB0aGF0IGlzIHRoZSBxdWVzdGlvbg==" }); // Long text
- * validator.parse({ encodedData: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==" }); // Base64 image
- *
- * // ❌ INVALID base64 strings
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ" });          // Wrong length (not multiple of 4)
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ===" });       // Too many padding chars (3)
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ====" });      // Too many padding chars (4)
- * validator.parse({ encodedData: "SGV@bG8gV29ybGQ=" });         // Invalid character (@)
- * validator.parse({ encodedData: "SGV sbG8gV29ybGQ=" });        // Space not allowed
- * validator.parse({ encodedData: "SGV\tbG8gV29ybGQ=" });        // Tab not allowed
- * validator.parse({ encodedData: "SGV\nbG8gV29ybGQ=" });        // Newline not allowed
- * validator.parse({ encodedData: "SGVsbG8\rgV29ybGQ=" });       // Carriage return not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=" });         // Non-standard characters
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ!=" });        // Exclamation mark not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ?=" });        // Question mark not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ&=" });        // Ampersand not allowed
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ*=" });        // Asterisk not allowed
- *
- * // Padding in wrong position
- * validator.parse({ encodedData: "SGVsbG=gV29ybGQ=" });         // Padding in middle
- * validator.parse({ encodedData: "=GVsbG8gV29ybGQ=" });         // Padding at start
- * validator.parse({ encodedData: "SGVsbG8=V29ybGQ=" });         // Padding before end
- *
- * // URL-safe base64 invalid examples
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ+" });        // + not allowed in URL-safe
- * urlSafeValidator.parse({ token: "SGVsbG8gV29ybGQ/" });        // / not allowed in URL-safe
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ-" });         // - not allowed in standard
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ_" });         // _ not allowed in standard
- *
- * // Edge cases
- * validator.parse({ encodedData: " SGVsbG8gV29ybGQ=" });        // Leading space
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ= " });        // Trailing space
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=\n" });       // Trailing newline
- * validator.parse({ encodedData: "SGVsbG8gV29ybGQ=\r\n" });     // CRLF at end
- * ```
- * @params
- * - options?: { messageFactory?: (context: MessageContext) => string; urlSafe?: boolean } - Optional configuration
- * @returns Validation function that checks base64 encoding
- * @customError
- * ```typescript
- * .base64({
- *   messageFactory: ({ path, value }) =>
- *     `${path} must be valid base64 encoded string (received: ${value.substring(0, 20)}...)`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-import type { MessageContext } from "../core/plugin/types";
-export declare const stringBase64Plugin: import("../index").TypedPlugin<"stringBase64", "base64", (options?: {
-    messageFactory?: (context: MessageContext) => string;
-    urlSafe?: boolean;
-}) => {
-    check: (value: string) => boolean;
-    code: string;
-    getErrorMessage: (value: string, path: string) => string;
-    messageFactory: (context: MessageContext) => string;
-    params: {
-        messageFactory?: (context: MessageContext) => string;
-        urlSafe?: boolean;
-    }[];
-}, readonly ["string"], "validator", "standard">;
+export * from "./string-base64/index";

package/dist/plugins/stringBase64.js

@@ -1 +1,2 @@
-"use strict";var l=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var d=(e,t)=>{for(var o in t)l(e,o,{get:t[o],enumerable:!0})},y=(e,t,o,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of g(t))!p.call(e,a)&&a!==o&&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,{stringBase64Plugin:()=>h});module.exports=c(I);var f=(e,t,o,n)=>{let r=(s=>(...m)=>{let i=s(...m);return i&&typeof i=="object"&&"check"in i?{...i,pluginName:n}:i})(o);switch(e){case"conditional":return(s,...m)=>r(s,...m);case"fieldReference":return(s,...m)=>r(s,...m);case"multiFieldReference":return r;case"transform":return s=>r(s);case"arrayElement":return(s,...m)=>r(s,...m);case"context":return s=>r(s);default:return r}};function T(e){let{name:t,methodName:o,allowedTypes:n,category:a,impl:r}=e;return{name:t,methodName:o,allowedTypes:n,category:a,create:()=>f(a,o,r,t)}}var N=/^[A-Za-z0-9+/]*={0,2}$/,x=/^[A-Za-z0-9\-_]*={0,2}$/,h=T({name:"stringBase64",methodName:"base64",allowedTypes:["string"],category:"standard",impl:e=>({check:n=>typeof n!="string"?!1:n===""?!0:n.length%4!==0?!1:(e?.urlSafe?x:N).test(n),code:"FORMAT_BASE64",getErrorMessage:(n,a)=>{let r={path:a,value:n,code:"FORMAT_BASE64"};return e?.messageFactory?.(r)||`${a} must be a valid base64 encoded string`},messageFactory:n=>e?.messageFactory?.(n)||`${n.path} must be a valid base64 encoded string`,params:[e]})});0&&(module.exports={stringBase64Plugin});
+"use strict";
+module.exports = require("./string-base64/index");

package/dist/plugins/stringBase64.mjs

@@ -1 +1 @@
-var T=(a,i,o,e)=>{let n=(t=>(...s)=>{let m=t(...s);return m&&typeof m=="object"&&"check"in m?{...m,pluginName:e}:m})(o);switch(a){case"conditional":return(t,...s)=>n(t,...s);case"fieldReference":return(t,...s)=>n(t,...s);case"multiFieldReference":return n;case"transform":return t=>n(t);case"arrayElement":return(t,...s)=>n(t,...s);case"context":return t=>n(t);default:return n}};function l(a){let{name:i,methodName:o,allowedTypes:e,category:r,impl:n}=a;return{name:i,methodName:o,allowedTypes:e,category:r,create:()=>T(r,o,n,i)}}var u=/^[A-Za-z0-9+/]*={0,2}$/,g=/^[A-Za-z0-9\-_]*={0,2}$/,y=l({name:"stringBase64",methodName:"base64",allowedTypes:["string"],category:"standard",impl:a=>({check:e=>typeof e!="string"?!1:e===""?!0:e.length%4!==0?!1:(a?.urlSafe?g:u).test(e),code:"FORMAT_BASE64",getErrorMessage:(e,r)=>{let n={path:r,value:e,code:"FORMAT_BASE64"};return a?.messageFactory?.(n)||`${r} must be a valid base64 encoded string`},messageFactory:e=>a?.messageFactory?.(e)||`${e.path} must be a valid base64 encoded string`,params:[a]})});export{y as stringBase64Plugin};
+export * from "./string-base64/index.mjs";

package/dist/plugins/stringContentEncoding.d.ts

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

package/dist/plugins/stringContentEncoding.js

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

package/dist/plugins/stringContentEncoding.mjs

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

package/dist/plugins/stringContentMediaType.d.ts

@@ -1,47 +1 @@
-/**
- * @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">;
+export * from "./string-content-media-type/index";

package/dist/plugins/stringContentMediaType.js

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

package/dist/plugins/stringContentMediaType.mjs

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

package/dist/plugins/stringDate.d.ts

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

package/dist/plugins/stringDate.js

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

package/dist/plugins/stringDate.mjs

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

package/dist/plugins/stringDatetime.d.ts

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

package/dist/plugins/stringDatetime.js

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

package/dist/plugins/stringDatetime.mjs

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

package/dist/plugins/stringDuration.d.ts

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

package/dist/plugins/stringDuration.js

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