reliant-type 1.0.0

package/dist/esm/core/schema/mode/interfaces/validators/ConstraintParser.js

@@ -0,0 +1,1132 @@
+import { ConstraintType } from '../../../../types/parser.type.js';
+import { VALID_CONDITIONNAL_TYPES, SUPPORTED_VALIDATOR_TYPES } from '../../../../types/ValidatorTypes.js';
+
+/**
+ * Constraint Parser Module - Enhanced Robust Version
+ *
+ * Optimized parsing of constraint syntax like "string(3,20)", "number(0,100)?", etc.
+ * Uses caching, pre-compiled patterns, and robust regex validation for maximum reliability.
+ */
+/**
+ * Enhanced constraint parser with robust regex patterns and bulletproof validation
+ */
+class ConstraintParser {
+    /**
+     * Parse constraint syntax with aggressive caching and robust validation
+     */
+    static parseConstraints(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            throw new Error("Invalid field type: must be a non-empty string");
+        }
+        // Check cache first
+        const cached = this._parseCache.get(fieldType);
+        if (cached) {
+            this._cacheHits++;
+            return this._deepClone(cached);
+        }
+        this._cacheMisses++;
+        const result = this._parseConstraintsInternal(fieldType);
+        // Cache the result with size limit
+        this._addToCache(fieldType, result);
+        return result;
+    }
+    /**
+     * Enhanced input validation
+     */
+    static _isValidInput(input) {
+        return (typeof input === "string" &&
+            input.length > 0 &&
+            !this._patterns.whitespaceOnly.test(input));
+    }
+    /**
+     * Deep clone utility for cache results
+     */
+    static _deepClone(obj) {
+        const cloned = {
+            type: obj.type,
+            constraints: {},
+            optional: obj.optional,
+            required: obj.required,
+        };
+        // Deep clone constraints object
+        if (obj.constraints && typeof obj.constraints === "object") {
+            for (const [key, value] of Object.entries(obj.constraints)) {
+                if (value instanceof RegExp) {
+                    cloned.constraints[key] = new RegExp(value.source, value.flags);
+                }
+                else if (typeof value === "object" && value !== null) {
+                    cloned.constraints[key] = { ...value };
+                }
+                else {
+                    cloned.constraints[key] = value;
+                }
+            }
+        }
+        return cloned;
+    }
+    /**
+     * Enhanced internal parsing logic with robust error handling
+     */
+    static _parseConstraintsInternal(fieldType) {
+        let optional = false;
+        let required = false;
+        let type = this._sanitizeInput(fieldType);
+        let constraints = {};
+        if (!type) {
+            throw new Error("Field type cannot be empty after sanitization");
+        }
+        // Enhanced optional marker detection
+        if (this._hasOptionalMarker(type)) {
+            optional = true;
+            type = this._removeOptionalMarker(type);
+            if (!type) {
+                throw new Error('Invalid field type: cannot be only "?"');
+            }
+        }
+        // Enhanced required marker detection
+        if (this._hasRequiredMarker(type)) {
+            required = true;
+            type = this._removeRequiredMarker(type);
+            if (!type) {
+                throw new Error('Invalid field type: cannot be only "!"');
+            }
+        }
+        // Enhanced union type detection
+        if (this._isUnionTypeInParentheses(type)) {
+            return { type, constraints: {}, optional, required };
+        }
+        // Enhanced constraint parsing with robust validation
+        const constraintMatch = this._parseBalancedConstraints(type);
+        if (constraintMatch) {
+            const { baseType, constraintStr } = constraintMatch;
+            type = baseType;
+            if (constraintStr) {
+                try {
+                    constraints = this._parseConstraintString(constraintStr, baseType);
+                }
+                catch (error) {
+                    throw new Error(`Invalid constraint syntax in "${fieldType}": ${this._getErrorMessage(error)}`);
+                }
+            }
+        }
+        // Check for conditional expressions (when ... *? ... : ...)
+        if (this._isConditionalExpression(type)) {
+            return { type, constraints: {}, optional, required };
+        }
+        // Enhanced base type validation
+        if (!this._isValidBaseType(type)) {
+            throw new Error(`Invalid base type: "${type}"`);
+        }
+        return { type, constraints, optional, required };
+    }
+    /**
+     * Check if type is a conditional expression using secure regex pattern
+     */
+    static _isConditionalExpression(type) {
+        // Secure regex pattern to match: when <condition> *? <thenValue> [: <elseValue>]
+        const conditionalPattern = /^\s*when\s+.+?\s*\*\?\s*.+/;
+        return conditionalPattern.test(type);
+    }
+    /**
+     * Enhanced input sanitization
+     */
+    static _sanitizeInput(input) {
+        if (typeof input !== "string") {
+            throw new Error("Input must be a string");
+        }
+        // Trim whitespace but preserve internal structure
+        return input.trim().replace(/\s+/g, " ");
+    }
+    /**
+     * Robust optional marker detection
+     */
+    static _hasOptionalMarker(type) {
+        return (type.length > 0 &&
+            type.charCodeAt(type.length - 1) === this._charCodes.questionMark &&
+            this._patterns.optionalMarker.test(type));
+    }
+    /**
+     * Safe optional marker removal
+     */
+    static _removeOptionalMarker(type) {
+        if (!this._hasOptionalMarker(type)) {
+            return type;
+        }
+        return type.slice(0, -1).trim();
+    }
+    /**
+     * Robust required marker detection
+     */
+    static _hasRequiredMarker(type) {
+        return (type.length > 0 &&
+            type.charCodeAt(type.length - 1) === this._charCodes.exclamation &&
+            this._patterns.requiredMarker.test(type));
+    }
+    /**
+     * Safe required marker removal
+     */
+    static _removeRequiredMarker(type) {
+        if (!this._hasRequiredMarker(type)) {
+            return type;
+        }
+        return type.slice(0, -1).trim();
+    }
+    /**
+     * Enhanced union type detection with regex validation
+     */
+    static _isUnionTypeInParentheses(type) {
+        return (this._patterns.unionType.test(type) &&
+            this._containsPipeOperator(type) &&
+            this._hasBalancedParentheses(type));
+    }
+    /**
+     * Check for pipe operator in union types
+     */
+    static _containsPipeOperator(type) {
+        for (let i = 0; i < type.length; i++) {
+            if (type.charCodeAt(i) === this._charCodes.pipe) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Validate balanced parentheses
+     */
+    static _hasBalancedParentheses(input) {
+        let depth = 0;
+        for (let i = 0; i < input.length; i++) {
+            const charCode = input.charCodeAt(i);
+            if (charCode === this._charCodes.openParen) {
+                depth++;
+            }
+            else if (charCode === this._charCodes.closeParen) {
+                depth--;
+                if (depth < 0) {
+                    return false;
+                }
+            }
+        }
+        return depth === 0;
+    }
+    /**
+     * Enhanced constraint parsing with robust parentheses handling
+     */
+    static _parseBalancedConstraints(type) {
+        const match = type.match(this._patterns.constraint);
+        if (!match) {
+            return null;
+        }
+        const [, baseType, constraintStr] = match;
+        // Enhanced base type validation
+        if (!this._patterns.baseType.test(baseType)) {
+            throw new Error(`Invalid base type format: "${baseType}"`);
+        }
+        // Validate constraint string is not empty
+        if (!constraintStr || this._patterns.whitespaceOnly.test(constraintStr)) {
+            throw new Error(`Empty constraint string in: "${type}"`);
+        }
+        // Validate balanced parentheses in constraint string
+        if (!this._validateConstraintParentheses(constraintStr)) {
+            throw new Error(`Unbalanced parentheses in constraint: "${type}"`);
+        }
+        return { baseType, constraintStr };
+    }
+    /**
+     * Validate parentheses balance in constraint strings
+     */
+    static _validateConstraintParentheses(constraintStr) {
+        let depth = 0;
+        let inRegex = false;
+        let escaped = false;
+        for (let i = 0; i < constraintStr.length; i++) {
+            const charCode = constraintStr.charCodeAt(i);
+            constraintStr[i];
+            // Handle regex pattern detection
+            if (charCode === this._charCodes.slash && !escaped) {
+                inRegex = !inRegex;
+                escaped = false;
+                continue;
+            }
+            // Handle escaping
+            if (charCode === this._charCodes.backslash && !escaped) {
+                escaped = true;
+                continue;
+            }
+            // Skip parentheses inside regex patterns
+            if (!inRegex) {
+                if (charCode === this._charCodes.openParen && !escaped) {
+                    depth++;
+                }
+                else if (charCode === this._charCodes.closeParen && !escaped) {
+                    depth--;
+                    if (depth < 0) {
+                        return false;
+                    }
+                }
+            }
+            escaped = false;
+        }
+        return depth === 0;
+    }
+    /**
+     * Enhanced constraint string parsing with robust error handling
+     */
+    static _parseConstraintString(constraintStr, baseType) {
+        const trimmed = constraintStr.trim();
+        if (!trimmed) {
+            return {};
+        }
+        const constraints = {};
+        // Enhanced regex pattern detection
+        const regexMatch = this._parseRegexPattern(trimmed);
+        if (regexMatch) {
+            constraints.pattern = regexMatch;
+            return constraints;
+        }
+        // Enhanced semicolon-separated complex constraints
+        if (this._containsCharCode(trimmed, this._charCodes.semicolon)) {
+            return this._parseComplexConstraints(trimmed);
+        }
+        // Enhanced min,max constraints
+        if (this._containsCharCode(trimmed, this._charCodes.comma)) {
+            return this._parseMinMaxConstraints(trimmed, baseType);
+        }
+        // Enhanced single value constraint
+        if (this._isValidNumericValue(trimmed)) {
+            const val = this._parseNumericValue(trimmed);
+            this._setConstraintValue(constraints, baseType, ConstraintType.Max, val);
+            return constraints;
+        }
+        throw new Error(`Unrecognized constraint format: "${trimmed}"`);
+    }
+    /**
+     * Enhanced regex pattern parsing
+     */
+    static _parseRegexPattern(input) {
+        const match = input.match(this._patterns.regex);
+        if (!match) {
+            return null;
+        }
+        try {
+            const [, pattern, flags] = match;
+            // Validate flags
+            if (flags && !this._isValidRegexFlags(flags)) {
+                throw new Error(`Invalid regex flags: "${flags}"`);
+            }
+            return new RegExp(pattern, flags || "");
+        }
+        catch (error) {
+            throw new Error(`Invalid regex pattern: ${this._getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Validate regex flags
+     */
+    static _isValidRegexFlags(flags) {
+        const validFlags = new Set(["g", "i", "m", "s", "u", "v", "y"]);
+        const flagSet = new Set();
+        for (const flag of flags) {
+            if (!validFlags.has(flag)) {
+                return false;
+            }
+            if (flagSet.has(flag)) {
+                return false; // Duplicate flag
+            }
+            flagSet.add(flag);
+        }
+        return true;
+    }
+    /**
+     * Check if string contains specific character code
+     */
+    static _containsCharCode(str, charCode) {
+        for (let i = 0; i < str.length; i++) {
+            if (str.charCodeAt(i) === charCode) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Enhanced numeric value validation
+     */
+    static _isValidNumericValue(value) {
+        if (!value || typeof value !== "string") {
+            return false;
+        }
+        return this._patterns.numeric.test(value.trim());
+    }
+    /**
+     * Safe numeric value parsing
+     */
+    static _parseNumericValue(value) {
+        const trimmed = value.trim();
+        if (!this._isValidNumericValue(trimmed)) {
+            throw new Error(`Invalid numeric value: "${value}"`);
+        }
+        const parsed = Number(trimmed);
+        if (!Number.isFinite(parsed)) {
+            throw new Error(`Non-finite numeric value: "${value}"`);
+        }
+        return parsed;
+    }
+    /**
+     * Enhanced min,max constraint parsing
+     */
+    static _parseMinMaxConstraints(constraintStr, baseType) {
+        const constraints = {};
+        const parts = constraintStr.split(this._patterns.commaSplit);
+        if (parts.length > 2) {
+            throw new Error(`Too many constraint values. Expected format: "min,max" but got: "${constraintStr}"`);
+        }
+        const [minStr, maxStr] = parts;
+        // Enhanced minimum value parsing
+        if (minStr && !this._patterns.whitespaceOnly.test(minStr)) {
+            const minVal = this._parseNumericValue(minStr);
+            this._setConstraintValue(constraints, baseType, ConstraintType.Min, minVal);
+        }
+        // Enhanced maximum value parsing
+        if (maxStr && !this._patterns.whitespaceOnly.test(maxStr)) {
+            const maxVal = this._parseNumericValue(maxStr);
+            this._setConstraintValue(constraints, baseType, ConstraintType.Max, maxVal);
+        }
+        // Enhanced min/max relationship validation
+        this._validateMinMaxRelationship(constraints);
+        return constraints;
+    }
+    /**
+     * Validate min/max constraint relationships
+     */
+    static _validateMinMaxRelationship(constraints) {
+        const pairs = [
+            ["min", "max"],
+            ["minLength", "maxLength"],
+            ["minItems", "maxItems"],
+        ];
+        for (const [minKey, maxKey] of pairs) {
+            if (constraints[minKey] !== undefined &&
+                constraints[maxKey] !== undefined) {
+                if (constraints[minKey] > constraints[maxKey]) {
+                    throw new Error(`${minKey} value (${constraints[minKey]}) cannot be greater than ${maxKey} value (${constraints[maxKey]})`);
+                }
+            }
+        }
+    }
+    /**
+     * Enhanced constraint value setting with robust validation
+     */
+    static _setConstraintValue(constraints, baseType, constraintType, value) {
+        // Enhanced negative value validation
+        if (!Number.isFinite(value)) {
+            throw new Error(`Constraint value must be finite: ${value}`);
+        }
+        // Type-specific negative value validation
+        if (this._isStringType(baseType) && value < 0) {
+            throw new Error("String length constraints cannot be negative");
+        }
+        if (this._isArrayType(baseType) && value < 0) {
+            throw new Error("Array length constraints cannot be negative");
+        }
+        // Set appropriate constraint based on type
+        if (this._isArrayType(baseType)) {
+            constraints[constraintType === ConstraintType.Min
+                ? ConstraintType.MinItems
+                : ConstraintType.MaxItems] = value;
+        }
+        else if (this._isStringType(baseType)) {
+            constraints[constraintType === ConstraintType.Min
+                ? ConstraintType.MinLength
+                : ConstraintType.MaxLength] = value;
+        }
+        else {
+            constraints[constraintType] = value;
+        }
+    }
+    /**
+     * Enhanced string type detection
+     */
+    static _isStringType(type) {
+        return (type === "string" ||
+            (this._patterns.baseType.test(type) && type.includes("string")));
+    }
+    /**
+     * Enhanced array type detection
+     */
+    static _isArrayType(type) {
+        return this._patterns.arrayType.test(type) || type.endsWith("[]");
+    }
+    /**
+     * Enhanced base type validation with comprehensive checks
+     */
+    static _isValidBaseType(type) {
+        if (!type || typeof type !== "string") {
+            return false;
+        }
+        // Enhanced whitespace validation
+        if (this._patterns.whitespaceOnly.test(type)) {
+            return false;
+        }
+        // Check valid conditional types
+        if (VALID_CONDITIONNAL_TYPES.includes(type)) {
+            return true;
+        }
+        // Enhanced union type validation
+        if (this._containsPipeOperator(type)) {
+            return this._validateUnionType(type);
+        }
+        // Enhanced literal value validation
+        if (this._patterns.literalValue.test(type)) {
+            return true;
+        }
+        // Enhanced Record type validation
+        if (this._isRecordType(type)) {
+            return true;
+        }
+        // Enhanced supported validator types check
+        if (SUPPORTED_VALIDATOR_TYPES.includes(type)) {
+            return true;
+        }
+        // Enhanced base type pattern validation
+        return this._patterns.baseType.test(type);
+    }
+    /**
+     * Validate union types
+     */
+    static _validateUnionType(type) {
+        const parts = type.split("|");
+        if (parts.length < 2) {
+            return false;
+        }
+        return parts.every((part) => {
+            const trimmed = part.trim();
+            return trimmed.length > 0 && !this._patterns.whitespaceOnly.test(trimmed);
+        });
+    }
+    /**
+     * Enhanced Record type detection
+     */
+    static _isRecordType(type) {
+        return (this._patterns.recordTypeLower.test(type) ||
+            this._patterns.recordTypeUpper.test(type));
+    }
+    /**
+     * Enhanced cache management with deep cloning
+     */
+    static _addToCache(key, value) {
+        if (this._parseCache.size >= this._maxCacheSize) {
+            const firstKey = this._parseCache.keys().next().value;
+            if (firstKey) {
+                this._parseCache.delete(firstKey);
+            }
+        }
+        this._parseCache.set(key, this._deepClone(value));
+    }
+    /**
+     * Enhanced complex constraint parsing
+     */
+    static _parseComplexConstraints(constraintStr) {
+        const constraints = {};
+        const parts = constraintStr
+            .split(this._patterns.semicolonSplit)
+            .map((part) => part.trim())
+            .filter((part) => !this._patterns.whitespaceOnly.test(part));
+        if (parts.length === 0) {
+            throw new Error("Empty complex constraint string");
+        }
+        for (const part of parts) {
+            try {
+                this._parseComplexConstraintPart(constraints, part);
+            }
+            catch (error) {
+                throw new Error(`Error parsing constraint "${part}": ${this._getErrorMessage(error)}`);
+            }
+        }
+        return constraints;
+    }
+    /**
+     * Parse individual complex constraint part
+     */
+    static _parseComplexConstraintPart(constraints, part) {
+        const colonParts = part.split(this._patterns.colonSplit);
+        if (colonParts.length !== 2) {
+            throw new Error(`Invalid constraint format. Expected "key:value" but got: "${part}"`);
+        }
+        const [key, value] = colonParts;
+        if (this._patterns.whitespaceOnly.test(key) ||
+            this._patterns.whitespaceOnly.test(value)) {
+            throw new Error(`Invalid constraint format. Both key and value must be non-empty: "${part}"`);
+        }
+        if (!this._patterns.constraintKey.test(key)) {
+            throw new Error(`Invalid constraint key format: "${key}"`);
+        }
+        this._parseComplexConstraintPair(constraints, key, value);
+    }
+    /**
+     * Enhanced individual constraint key-value pair parsing
+     */
+    static _parseComplexConstraintPair(constraints, key, value) {
+        switch (key) {
+            case ConstraintType.Min:
+            case ConstraintType.Max:
+            case ConstraintType.MinLength:
+            case ConstraintType.MaxLength:
+            case ConstraintType.MinItems:
+            case ConstraintType.MaxItems:
+                const numValue = this._parseNumericValue(value);
+                if (numValue < 0 && (key.includes("Length") || key.includes("Items"))) {
+                    throw new Error(`"${key}" cannot be negative`);
+                }
+                constraints[key] = numValue;
+                break;
+            case "pattern":
+                const regexPattern = this._parseRegexPattern(value);
+                if (!regexPattern) {
+                    throw new Error(`Pattern must be in regex format (/pattern/flags): "${value}"`);
+                }
+                constraints.pattern = regexPattern;
+                break;
+            case "unique":
+                if (!this._patterns.booleanValue.test(value)) {
+                    throw new Error(`"unique" must be "true" or "false", got: "${value}"`);
+                }
+                constraints.unique = value.toLowerCase() === "true";
+                break;
+            default:
+                throw new Error(`Unknown constraint key: "${key}"`);
+        }
+    }
+    /**
+     * Enhanced error message extraction
+     */
+    static _getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === "string") {
+            return error;
+        }
+        return "Unknown error";
+    }
+    // Enhanced public utility methods with stronger validation
+    /**
+     * Check if a field type has constraints - enhanced validation
+     */
+    static hasConstraints(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return false;
+        }
+        const sanitized = this._sanitizeInput(fieldType);
+        const withoutModifiers = sanitized
+            .replace(this._patterns.optionalMarker, "")
+            .replace(this._patterns.requiredMarker, "");
+        return this._patterns.complexConstraint.test(withoutModifiers);
+    }
+    /**
+     * Extract base type without constraints - enhanced
+     */
+    static getBaseType(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return "";
+        }
+        try {
+            const parsed = this.parseConstraints(fieldType);
+            return parsed.type;
+        }
+        catch {
+            // Enhanced fallback with regex
+            const sanitized = this._sanitizeInput(fieldType);
+            return sanitized
+                .replace(/\([^)]*\)/, "")
+                .replace(this._patterns.optionalMarker, "")
+                .replace(this._patterns.requiredMarker, "")
+                .trim();
+        }
+    }
+    /**
+     * Check if field type is optional - enhanced
+     */
+    static isOptional(fieldType) {
+        return this._isValidInput(fieldType) && this._hasOptionalMarker(fieldType);
+    }
+    /**
+     * Check if field type is required - enhanced
+     */
+    static isRequired(fieldType) {
+        return this._isValidInput(fieldType) && this._hasRequiredMarker(fieldType);
+    }
+    /**
+     * Check if field type is an array - enhanced
+     */
+    static isArrayType(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return false;
+        }
+        try {
+            const parsed = this.parseConstraints(fieldType);
+            return this._isArrayType(parsed.type);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get element type for array types - enhanced
+     */
+    static getElementType(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return fieldType;
+        }
+        try {
+            const parsed = this.parseConstraints(fieldType);
+            if (this._isArrayType(parsed.type)) {
+                return parsed.type.replace(/\[\]$/, "");
+            }
+            return parsed.type;
+        }
+        catch {
+            return fieldType;
+        }
+    }
+    /**
+     * Enhanced constraint validation
+     */
+    static validateConstraints(constraints, type) {
+        if (!constraints || typeof constraints !== "object") {
+            return [];
+        }
+        const errors = [];
+        try {
+            // Enhanced min/max validation
+            this._validateMinMaxRelationship(constraints);
+            // Enhanced type-specific validation
+            this._validateTypeSpecificConstraints(constraints, type, errors);
+            // Enhanced regex pattern validation
+            if (constraints.pattern && !(constraints.pattern instanceof RegExp)) {
+                errors.push("Pattern constraint must be a RegExp object");
+            }
+            // Enhanced negative value validation
+            this._validateNegativeConstraints(constraints, errors);
+        }
+        catch (error) {
+            errors.push(`Constraint validation error: ${this._getErrorMessage(error)}`);
+        }
+        return errors;
+    }
+    /**
+     * Validate type-specific constraints
+     */
+    static _validateTypeSpecificConstraints(constraints, type, errors) {
+        if (type === "positive" &&
+            constraints.min !== undefined &&
+            constraints.min < 0) {
+            errors.push("Positive type cannot have negative minimum value");
+        }
+        if (type === "negative" &&
+            constraints.max !== undefined &&
+            constraints.max > 0) {
+            errors.push("Negative type cannot have positive maximum value");
+        }
+    }
+    /**
+     * Validate negative constraints
+     */
+    static _validateNegativeConstraints(constraints, errors) {
+        const lengthKeys = [
+            ConstraintType.MinLength,
+            ConstraintType.MaxLength,
+            ConstraintType.MinItems,
+            ConstraintType.MaxItems,
+        ];
+        lengthKeys.forEach((key) => {
+            if (constraints[key] !== undefined && constraints[key] < 0) {
+                errors.push(`${key} cannot be negative`);
+            }
+        });
+    }
+    /**
+     * Enhanced constraint merging
+     */
+    static mergeConstraints(baseOptions, constraints) {
+        if (!baseOptions && !constraints) {
+            return {};
+        }
+        if (!baseOptions) {
+            return this._deepCloneObject(constraints);
+        }
+        if (!constraints) {
+            return this._deepCloneObject(baseOptions);
+        }
+        const merged = { ...baseOptions };
+        // Enhanced merging with conflict resolution
+        for (const [key, value] of Object.entries(constraints)) {
+            if (value instanceof RegExp) {
+                merged[key] = new RegExp(value.source, value.flags);
+            }
+            else if (typeof value === "object" && value !== null) {
+                merged[key] = { ...value };
+            }
+            else {
+                merged[key] = value;
+            }
+        }
+        return merged;
+    }
+    /**
+     * Deep clone utility for objects
+     */
+    static _deepCloneObject(obj) {
+        if (!obj || typeof obj !== "object") {
+            return obj;
+        }
+        const cloned = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value instanceof RegExp) {
+                cloned[key] = new RegExp(value.source, value.flags);
+            }
+            else if (typeof value === "object" && value !== null) {
+                cloned[key] = { ...value };
+            }
+            else {
+                cloned[key] = value;
+            }
+        }
+        return cloned;
+    }
+    /**
+     * Enhanced cache clearing with statistics reset
+     */
+    static clearCache() {
+        this._parseCache.clear();
+        this._cacheHits = 0;
+        this._cacheMisses = 0;
+    }
+    /**
+     * Enhanced cache statistics with additional metrics
+     */
+    static getCacheStats() {
+        const total = this._cacheHits + this._cacheMisses;
+        const hitRate = total > 0 ? this._cacheHits / total : 0;
+        const efficiency = this._parseCache.size > 0 ? hitRate : 0;
+        return {
+            size: this._parseCache.size,
+            hitRate: Number(hitRate.toFixed(4)),
+            hits: this._cacheHits,
+            misses: this._cacheMisses,
+            maxSize: this._maxCacheSize,
+            efficiency: Number(efficiency.toFixed(4)),
+        };
+    }
+    /**
+     * Enhanced constraint description with better formatting
+     */
+    static getConstraintDescription(constraints, _type) {
+        if (!constraints || typeof constraints !== "object") {
+            return "";
+        }
+        const descriptions = [];
+        try {
+            const constraintKeys = [
+                ConstraintType.Min,
+                ConstraintType.Max,
+                ConstraintType.MinLength,
+                ConstraintType.MaxLength,
+                ConstraintType.MinItems,
+                ConstraintType.MaxItems,
+            ];
+            constraintKeys.forEach((key) => {
+                if (constraints[key] !== undefined &&
+                    Number.isFinite(constraints[key])) {
+                    descriptions.push(`${key}: ${constraints[key]}`);
+                }
+            });
+            if (constraints.pattern instanceof RegExp) {
+                const flags = constraints.pattern.flags
+                    ? `/${constraints.pattern.flags}`
+                    : "";
+                descriptions.push(`pattern: /${constraints.pattern.source}${flags}`);
+            }
+            if (constraints.unique === true) {
+                descriptions.push("unique: true");
+            }
+            // Enhanced description formatting
+            return descriptions.length > 0 ? `(${descriptions.join(", ")})` : "";
+        }
+        catch (error) {
+            return `(invalid constraints: ${this._getErrorMessage(error)})`;
+        }
+    }
+    /**
+     * Enhanced complex constraint parsing (public interface)
+     */
+    static parseComplexConstraints(constraintStr) {
+        if (!this._isValidInput(constraintStr)) {
+            throw new Error("Invalid constraint string: must be a non-empty string");
+        }
+        try {
+            return this._parseComplexConstraints(constraintStr);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse complex constraints "${constraintStr}": ${this._getErrorMessage(error)}`);
+        }
+    }
+    // Additional enhanced utility methods
+    /**
+     * Validate field type format comprehensively
+     */
+    static isValidFieldType(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return false;
+        }
+        try {
+            this.parseConstraints(fieldType);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Extract all modifiers from field type
+     */
+    static getFieldTypeModifiers(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return { optional: false, required: false, hasConstraints: false };
+        }
+        try {
+            const parsed = this.parseConstraints(fieldType);
+            return {
+                optional: parsed.optional,
+                required: parsed.required,
+                hasConstraints: Object.keys(parsed.constraints).length > 0,
+            };
+        }
+        catch {
+            return {
+                optional: this.isOptional(fieldType),
+                required: this.isRequired(fieldType),
+                hasConstraints: this.hasConstraints(fieldType),
+            };
+        }
+    }
+    /**
+     * Normalize field type string
+     */
+    static normalizeFieldType(fieldType) {
+        if (!this._isValidInput(fieldType)) {
+            return "";
+        }
+        try {
+            const parsed = this.parseConstraints(fieldType);
+            let normalized = parsed.type;
+            // Add constraints back if they exist
+            if (Object.keys(parsed.constraints).length > 0) {
+                const constraintDesc = this._formatConstraintsForType(parsed.constraints);
+                if (constraintDesc) {
+                    normalized += `(${constraintDesc})`;
+                }
+            }
+            // Add modifiers back
+            if (parsed.required) {
+                normalized += "!";
+            }
+            if (parsed.optional) {
+                normalized += "?";
+            }
+            return normalized;
+        }
+        catch {
+            return this._sanitizeInput(fieldType);
+        }
+    }
+    /**
+     * Format constraints for type reconstruction
+     */
+    static _formatConstraintsForType(constraints) {
+        if (!constraints || typeof constraints !== "object") {
+            return "";
+        }
+        const parts = [];
+        // Handle regex pattern
+        if (constraints.pattern instanceof RegExp) {
+            const flags = constraints.pattern.flags || "";
+            parts.push(`/${constraints.pattern.source}/${flags}`);
+            return parts.join(";");
+        }
+        // Handle min/max pairs
+        if (constraints.min !== undefined && constraints.max !== undefined) {
+            parts.push(`${constraints.min},${constraints.max}`);
+        }
+        else if (constraints.min !== undefined) {
+            parts.push(`${constraints.min},`);
+        }
+        else if (constraints.max !== undefined) {
+            parts.push(`${constraints.max}`);
+        }
+        // Handle length constraints
+        if (constraints.minLength !== undefined &&
+            constraints.maxLength !== undefined) {
+            if (parts.length === 0) {
+                parts.push(`${constraints.minLength},${constraints.maxLength}`);
+            }
+            else {
+                parts.push(`minLength:${constraints.minLength};maxLength:${constraints.maxLength}`);
+            }
+        }
+        // Handle items constraints
+        if (constraints.minItems !== undefined &&
+            constraints.maxItems !== undefined) {
+            if (parts.length === 0) {
+                parts.push(`${constraints.minItems},${constraints.maxItems}`);
+            }
+            else {
+                parts.push(`minItems:${constraints.minItems};maxItems:${constraints.maxItems}`);
+            }
+        }
+        // Handle unique
+        if (constraints.unique === true) {
+            parts.push("unique:true");
+        }
+        return parts.join(";");
+    }
+    /**
+     * Performance monitoring utilities
+     */
+    static getParsingPerformance() {
+        const total = this._cacheHits + this._cacheMisses;
+        const hitRatio = total > 0 ? this._cacheHits / total : 0;
+        return {
+            totalParses: total,
+            cacheHitRatio: Number(hitRatio.toFixed(4)),
+            averageParseTime: 0, // Would need instrumentation
+            memoryUsage: this._parseCache.size * 100, // Rough estimate
+        };
+    }
+    /**
+     * Optimize cache by removing least recently used entries
+     */
+    static optimizeCache() {
+        if (this._parseCache.size <= this._maxCacheSize * 0.8) {
+            return; // No optimization needed
+        }
+        const entries = Array.from(this._parseCache.entries());
+        const keepSize = Math.floor(this._maxCacheSize * 0.6);
+        // Keep most recent entries (simple LRU approximation)
+        this._parseCache.clear();
+        entries.slice(-keepSize).forEach(([key, value]) => {
+            this._parseCache.set(key, value);
+        });
+    }
+    /**
+     * Validate constraint compatibility with field type
+     */
+    static validateConstraintCompatibility(fieldType, constraints) {
+        const errors = [];
+        if (!this._isValidInput(fieldType)) {
+            errors.push("Invalid field type");
+            return { valid: false, errors };
+        }
+        if (!constraints || typeof constraints !== "object") {
+            return { valid: true, errors: [] };
+        }
+        try {
+            const parsed = this.parseConstraints(fieldType);
+            const baseType = parsed.type;
+            // Check string-specific constraints
+            if (!this._isStringType(baseType)) {
+                if (constraints.minLength !== undefined ||
+                    constraints.maxLength !== undefined) {
+                    errors.push("Length constraints are only valid for string types");
+                }
+                if (constraints.pattern !== undefined) {
+                    errors.push("Pattern constraints are only valid for string types");
+                }
+            }
+            // Check array-specific constraints
+            if (!this._isArrayType(baseType)) {
+                if (constraints.minItems !== undefined ||
+                    constraints.maxItems !== undefined) {
+                    errors.push("Item constraints are only valid for array types");
+                }
+                if (constraints.unique !== undefined) {
+                    errors.push("Unique constraints are only valid for array types");
+                }
+            }
+            // Check numeric-specific constraints
+            const numericTypes = ["number", "integer", "positive", "negative"];
+            if (!numericTypes.some((t) => baseType.includes(t))) {
+                if (constraints.min !== undefined || constraints.max !== undefined) {
+                    errors.push("Min/Max constraints are only valid for numeric types");
+                }
+            }
+        }
+        catch (error) {
+            errors.push(`Type parsing error: ${this._getErrorMessage(error)}`);
+        }
+        return { valid: errors.length === 0, errors };
+    }
+}
+// Private static properties for better encapsulation
+ConstraintParser._parseCache = new Map();
+ConstraintParser._maxCacheSize = 1000;
+ConstraintParser._cacheHits = 0;
+ConstraintParser._cacheMisses = 0;
+// pre-compiled regex patterns with stronger validation
+ConstraintParser._patterns = {
+    // Robust constraint pattern - handles complex nested patterns
+    constraint: /^([a-zA-Z_][a-zA-Z0-9_]*(?:\[\])*)\((.+)\)$/,
+    // Enhanced regex pattern detection with proper escaping
+    regex: /^\/(.+?)\/([gimsuvy]*)$/,
+    // Precise comma splitting that handles whitespace
+    commaSplit: /\s*,\s*/,
+    // Robust numeric validation including scientific notation and edge cases
+    numeric: /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/,
+    // Strict base type validation
+    baseType: /^[a-zA-Z_][a-zA-Z0-9_]*(?:\[\])*$/,
+    // Enhanced complex constraint detection
+    complexConstraint: /^[a-zA-Z_][a-zA-Z0-9_]*(?:\[\])*\([^)]*\)$/,
+    // Union type detection with balanced parentheses
+    unionType: /^\([^()]*(?:\|[^()]*)+\)$/,
+    // Record type detection (both cases)
+    recordTypeLower: /^record<[^<>]+>$/i,
+    recordTypeUpper: /^Record<[^<>]+>$/,
+    // Optional marker validation
+    optionalMarker: /\?$/,
+    // Required marker validation
+    requiredMarker: /!$/,
+    // Whitespace validation
+    whitespaceOnly: /^\s*$/,
+    // Constraint key validation
+    constraintKey: /^[a-zA-Z][a-zA-Z0-9_]*$/,
+    // Balanced parentheses validation
+    balancedParens: /^[^()]*(?:\([^()]*\)[^()]*)*$/,
+    // Array type detection
+    arrayType: /^[a-zA-Z_][a-zA-Z0-9_]*\[\]$/,
+    // Equal sign prefix for literal values
+    literalValue: /^=/,
+    // Boolean value validation
+    booleanValue: /^(?:true|false)$/i,
+    // Enhanced semicolon split for complex constraints
+    semicolonSplit: /\s*;\s*/,
+    // Colon split for key-value pairs
+    colonSplit: /\s*:\s*/,
+};
+// Character codes for optimized checks
+ConstraintParser._charCodes = {
+    questionMark: 63, // '?'
+    exclamation: 33, // '!'
+    openParen: 40, // '('
+    closeParen: 41, // ')'
+    comma: 44, // ','
+    semicolon: 59, // ';'
+    colon: 58, // ':'
+    pipe: 124, // '|'
+    openBracket: 91, // '['
+    closeBracket: 93, // ']'
+    slash: 47, // '/'
+    backslash: 92, // '\'
+    equal: 61, // '='
+};
+
+export { ConstraintParser };
+//# sourceMappingURL=ConstraintParser.js.map