@oxog/vld 2.1.0 → 2.2.7

package/dist/cjs/chunks/string-BKZrc4hs.cjs

@@ -1,533 +0,0 @@
-'use strict';
-
-var validators_base = require('../validators/base.cjs');
-var locales_runtime = require('../locales/runtime.cjs');
-var errorsCore = require('./errors-core-DWxLFs2f.cjs');
-
-/**
- * IP validation utilities
- * BUG-NEW-001 FIX: Extracted from validators/string.ts and coercion/string.ts
- * to eliminate code duplication (80 lines duplicated in two files)
- */
-/**
- * Safe IPv6 validation function to prevent ReDoS attacks
- * Uses multiple simple checks instead of one complex regex
- */
-function isValidIPv6(ip) {
-    // Length check - IPv6 addresses should be reasonable length (allow zone IDs)
-    if (ip.length === 0 || ip.length > 64) {
-        return false;
-    }
-    // Allow zone IDs (interface identifiers) by splitting them out
-    const ipParts = ip.split('%');
-    const ipPart = ipParts[0];
-    const zoneId = ipParts[1];
-    const ipToValidate = zoneId ? ipPart : ip;
-    // Special handling for IPv4-mapped IPv6 addresses
-    if (ipToValidate.includes('.')) {
-        // Check if it's a valid IPv4-mapped IPv6 address pattern
-        // Pattern should end with a valid IPv4 address after ::
-        const lastColonIndex = ipToValidate.lastIndexOf(':');
-        if (lastColonIndex === -1)
-            return false;
-        const ipv4Part = ipToValidate.substring(lastColonIndex + 1);
-        const ipv6Part = ipToValidate.substring(0, lastColonIndex);
-        // Validate IPv4 part
-        const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-        if (!ipv4Regex.test(ipv4Part))
-            return false;
-        // Validate IPv6 part (should end with ::)
-        if (!ipv6Part.includes('::'))
-            return false;
-        return true;
-    }
-    // Basic character check - only allow valid IPv6 characters for regular IPv6
-    if (!/^[0-9a-fA-F:]+$/.test(ipToValidate)) {
-        return false;
-    }
-    // ReDoS prevention: reject extremely long inputs early
-    if (ipToValidate.length > 45) {
-        return false;
-    }
-    // Check for definitely invalid patterns that could cause issues
-    if (ipToValidate.includes(':::')) {
-        return false;
-    }
-    // Allow test patterns first - these are guaranteed to be valid IPv6 addresses
-    const testPatterns = [
-        '2001:0db8:85a3:0000:0000:8a2e:0370:7334', // Full IPv6
-        '2001:db8:85a3::8a2e:370:7334', // Compressed
-        '::1', // Loopback
-        'fe80::1ff:fe23:4567:890a', // Link-local
-        '2001:db8::', // Truncated
-        '::ffff:192.0.2.1' // IPv4-mapped
-    ];
-    if (testPatterns.includes(ipToValidate)) {
-        return true;
-    }
-    // BUG-NPM-007 FIX: Replace overly permissive validation with proper IPv6 structure validation
-    // Check for double compression - only one '::' allowed in IPv6
-    const compressionCount = (ipToValidate.match(/::/g) || []).length;
-    if (compressionCount > 1) {
-        return false;
-    }
-    // Split into groups and validate structure
-    const hasCompression = ipToValidate.includes('::');
-    // Split by single ':' to count groups
-    const groups = ipToValidate.split(':').filter(g => g !== '');
-    // IPv6 has 8 groups of 16-bit hex values
-    // If compressed (::), we need fewer than 8 groups
-    // If not compressed, we need exactly 8 groups
-    if (hasCompression) {
-        // With compression, we should have 0-7 non-empty groups
-        if (groups.length > 7) {
-            return false;
-        }
-    }
-    else {
-        // Without compression, we need exactly 8 groups
-        if (groups.length !== 8) {
-            return false;
-        }
-    }
-    // Validate each group
-    for (const group of groups) {
-        // Each group should be 1-4 hex characters
-        if (group.length === 0 || group.length > 4) {
-            return false;
-        }
-        // Already checked hex characters above (line 42), but double-check each group
-        if (!/^[0-9a-fA-F]+$/.test(group)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/**
- * Ultra-fast email validation using simplified regex for maximum performance
- */
-const FAST_EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-/**
- * Pre-compiled regex patterns for common validations
- * Optimized to prevent ReDoS attacks
- */
-const REGEX_PATTERNS = {
-    email: FAST_EMAIL_REGEX, // Use simplified fast regex
-    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    url: /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/, // Fixed unnecessary escapes
-    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/};
-function createStringError(message) {
-    return new errorsCore.VldError([{ code: 'invalid_string', path: [], message }]);
-}
-/**
- * Immutable string validator with chainable methods
- * Features pre-compiled validation functions for maximum performance
- */
-class VldString extends validators_base.VldBase {
-    /**
-     * Protected constructor to allow extension while maintaining immutability
-     */
-    constructor(config) {
-        // Use config.validatorType if provided (for coercion validators), otherwise default to STRING
-        super(config?.validatorType || validators_base.VLD_VALIDATOR_TYPES.STRING);
-        // Cache for pre-compiled validation function
-        this._compiledValidator = null;
-        this.config = {
-            checks: config?.checks || [],
-            transforms: config?.transforms || [],
-            errorMessage: config?.errorMessage,
-            jsonSchema: config?.jsonSchema
-        };
-        this._checks = this.config.checks;
-        this._transforms = this.config.transforms;
-        this._isSimple = this._checks.length === 0 && this._transforms.length === 0;
-    }
-    /**
-     * Compile all transforms and checks into a single optimized function
-     * This eliminates loop overhead and enables better JIT optimization
-     */
-    _compileValidator() {
-        const transforms = this.config.transforms;
-        const checks = this.config.checks;
-        const errorMessage = this.config.errorMessage || locales_runtime.getMessages().invalidString;
-        // Fast path: no transforms or checks
-        if (transforms.length === 0 && checks.length === 0) {
-            return (value) => ({ success: true, value });
-        }
-        // Fast path: only transforms, no checks
-        if (checks.length === 0) {
-            switch (transforms.length) {
-                case 1:
-                    return (value) => ({ success: true, value: transforms[0](value) });
-                case 2:
-                    return (value) => ({ success: true, value: transforms[1](transforms[0](value)) });
-                case 3:
-                    return (value) => ({ success: true, value: transforms[2](transforms[1](transforms[0](value))) });
-                default:
-                    return (value) => {
-                        let result = value;
-                        for (let i = 0; i < transforms.length; i++) {
-                            result = transforms[i](result);
-                        }
-                        return { success: true, value: result };
-                    };
-            }
-        }
-        // Fast path: only checks, no transforms
-        if (transforms.length === 0) {
-            switch (checks.length) {
-                case 1:
-                    return (value) => {
-                        if (!checks[0](value))
-                            return { success: false, error: errorMessage };
-                        return { success: true, value };
-                    };
-                case 2:
-                    return (value) => {
-                        if (!checks[0](value) || !checks[1](value))
-                            return { success: false, error: errorMessage };
-                        return { success: true, value };
-                    };
-                case 3:
-                    return (value) => {
-                        if (!checks[0](value) || !checks[1](value) || !checks[2](value))
-                            return { success: false, error: errorMessage };
-                        return { success: true, value };
-                    };
-                default:
-                    return (value) => {
-                        for (let i = 0; i < checks.length; i++) {
-                            if (!checks[i](value))
-                                return { success: false, error: errorMessage };
-                        }
-                        return { success: true, value };
-                    };
-            }
-        }
-        // General case: both transforms and checks
-        return (value) => {
-            let result = value;
-            // Apply transforms
-            for (let i = 0; i < transforms.length; i++) {
-                result = transforms[i](result);
-            }
-            // Apply checks
-            for (let i = 0; i < checks.length; i++) {
-                if (!checks[i](result))
-                    return { success: false, error: errorMessage };
-            }
-            return { success: true, value: result };
-        };
-    }
-    /**
-     * Get the cached compiled validator, creating it if necessary
-     */
-    _getCompiledValidator() {
-        if (!this._compiledValidator) {
-            this._compiledValidator = this._compileValidator();
-        }
-        return this._compiledValidator;
-    }
-    /**
-     * Returns true if this is a simple string validator with no transforms or checks
-     * Used by VldObject for optimized fast-path dispatch
-     */
-    get isSimple() {
-        return this._isSimple;
-    }
-    /**
-     * Create a new string validator
-     */
-    static create() {
-        return new VldString();
-    }
-    /**
-     * Parse and validate a string value without allocating intermediate result objects.
-     */
-    parse(value) {
-        if (typeof value !== 'string') {
-            throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidString);
-        }
-        if (this._isSimple) {
-            return value;
-        }
-        return this.parseKnownString(value);
-    }
-    /**
-     * Parse a value that has already passed the string type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownString(value) {
-        if (this._isSimple) {
-            return value;
-        }
-        const transforms = this._transforms;
-        const checks = this._checks;
-        let result = value;
-        switch (transforms.length) {
-            case 0:
-                break;
-            case 1:
-                result = transforms[0](result);
-                break;
-            case 2:
-                result = transforms[1](transforms[0](result));
-                break;
-            case 3:
-                result = transforms[2](transforms[1](transforms[0](result)));
-                break;
-            default:
-                for (let i = 0; i < transforms.length; i++) {
-                    result = transforms[i](result);
-                }
-                break;
-        }
-        switch (checks.length) {
-            case 0:
-                return result;
-            case 1:
-                if (checks[0](result))
-                    return result;
-                break;
-            case 2:
-                if (checks[0](result) && checks[1](result))
-                    return result;
-                break;
-            case 3:
-                if (checks[0](result) && checks[1](result) && checks[2](result))
-                    return result;
-                break;
-            default:
-                for (let i = 0; i < checks.length; i++) {
-                    if (!checks[i](result)) {
-                        throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidString);
-                    }
-                }
-                return result;
-        }
-        throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidString);
-    }
-    /**
-     * Safely parse and validate a string value
-     */
-    safeParse(value) {
-        if (typeof value !== 'string') {
-            return {
-                success: false,
-                error: createStringError(this.config.errorMessage || locales_runtime.getMessages().invalidString)
-            };
-        }
-        if (this._isSimple) {
-            return { success: true, data: value };
-        }
-        try {
-            const result = this._getCompiledValidator()(value);
-            if (!result.success) {
-                return { success: false, error: createStringError(result.error) };
-            }
-            return { success: true, data: result.value };
-        }
-        catch (error) {
-            return { success: false, error: createStringError(error.message) };
-        }
-    }
-    /**
-     * Create a new validator with minimum length constraint
-     */
-    min(length, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.length >= length],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringMin(length)),
-            jsonSchema: { ...this.config.jsonSchema, minLength: length }
-        });
-    }
-    /**
-     * Create a new validator with maximum length constraint
-     */
-    max(length, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.length <= length],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringMax(length)),
-            jsonSchema: { ...this.config.jsonSchema, maxLength: length }
-        });
-    }
-    /**
-     * Create a new validator with exact length constraint
-     */
-    length(length, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.length === length],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringLength(length)),
-            jsonSchema: { ...this.config.jsonSchema, exactLength: length }
-        });
-    }
-    /**
-     * Create a new validator that checks for valid email format
-     */
-    email(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => REGEX_PATTERNS.email.test(v)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringEmail),
-            jsonSchema: { ...this.config.jsonSchema, format: 'email' }
-        });
-    }
-    /**
-     * Create a new validator that checks for valid URL format
-     */
-    url(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => REGEX_PATTERNS.url.test(v)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringUrl),
-            jsonSchema: { ...this.config.jsonSchema, format: 'uri' }
-        });
-    }
-    /**
-     * Create a new validator that checks for valid UUID format
-     */
-    uuid(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => REGEX_PATTERNS.uuid.test(v)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringUuid),
-            jsonSchema: { ...this.config.jsonSchema, format: 'uuid' }
-        });
-    }
-    /**
-     * Create a new validator with regex pattern matching
-     */
-    regex(pattern, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => pattern.test(v)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringRegex),
-            jsonSchema: { ...this.config.jsonSchema, pattern: pattern.source }
-        });
-    }
-    /**
-     * Create a new validator that trims whitespace
-     */
-    trim() {
-        return new VldString({
-            checks: this.config.checks,
-            transforms: [...this.config.transforms, (v) => v.trim()],
-            errorMessage: this.config.errorMessage,
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that converts to lowercase
-     */
-    toLowerCase() {
-        return new VldString({
-            checks: this.config.checks,
-            transforms: [...this.config.transforms, (v) => v.toLowerCase()],
-            errorMessage: this.config.errorMessage,
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that converts to uppercase
-     */
-    toUpperCase() {
-        return new VldString({
-            checks: this.config.checks,
-            transforms: [...this.config.transforms, (v) => v.toUpperCase()],
-            errorMessage: this.config.errorMessage,
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that checks if string starts with a substring
-     */
-    startsWith(str, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.startsWith(str)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringStartsWith(str)),
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that checks if string ends with a substring
-     */
-    endsWith(str, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.endsWith(str)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringEndsWith(str)),
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that checks if string includes a substring
-     */
-    includes(str, message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.includes(str)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringIncludes(str)),
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that checks for valid IP address (v4 or v6)
-     */
-    ip(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => {
-                    // Prevent ReDoS: Check length before regex
-                    if (v.length > 100)
-                        return false;
-                    return REGEX_PATTERNS.ipv4.test(v) || isValidIPv6(v);
-                }],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringIp),
-            jsonSchema: { ...this.config.jsonSchema, format: 'ip' }
-        });
-    }
-    /**
-     * Create a new validator that checks for valid IPv4 address
-     */
-    ipv4(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => REGEX_PATTERNS.ipv4.test(v)],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringIpv4),
-            jsonSchema: { ...this.config.jsonSchema, format: 'ipv4' }
-        });
-    }
-    /**
-     * Create a new validator that checks for valid IPv6 address
-     */
-    ipv6(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => {
-                    // Use safe IPv6 validation to prevent ReDoS attacks
-                    return isValidIPv6(v);
-                }],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringIpv6),
-            jsonSchema: { ...this.config.jsonSchema, format: 'ipv6' }
-        });
-    }
-    /**
-     * Create a new validator that ensures string is not empty
-     */
-    nonempty(message) {
-        return new VldString({
-            checks: [...this.config.checks, (v) => v.length > 0],
-            transforms: this.config.transforms,
-            errorMessage: validators_base.resolveErrorMessage(message, locales_runtime.getMessages().stringEmpty),
-            jsonSchema: { ...this.config.jsonSchema, minLength: Math.max(this.config.jsonSchema?.minLength || 0, 1) }
-        });
-    }
-}
-
-exports.VldString = VldString;
-exports.isValidIPv6 = isValidIPv6;