@angular-helpers/security 21.0.0 → 21.0.2

package/fesm2022/angular-helpers-security.mjs

@@ -0,0 +1,407 @@
+import * as i0 from '@angular/core';
+import { inject, DestroyRef, Injectable } from '@angular/core';
+
+/**
+ * Security service for regular expressions that prevents ReDoS
+ * using Web Workers for safe execution with timeout
+ */
+class RegexSecurityService {
+    destroyRef = inject(DestroyRef);
+    workers = new Map();
+    /**
+     * Builder pattern to construct safe regular expressions
+     */
+    static builder() {
+        return new RegexSecurityBuilder();
+    }
+    /**
+     * Executes a regular expression safely with a timeout
+     */
+    async testRegex(pattern, text, config = {}) {
+        const startTime = performance.now();
+        const finalConfig = this.mergeConfig(config);
+        try {
+            // First, analyze pattern security
+            const securityCheck = await this.analyzePatternSecurity(pattern);
+            if (!securityCheck.safe && !finalConfig.safeMode) {
+                return {
+                    match: false,
+                    executionTime: performance.now() - startTime,
+                    timeout: false,
+                    error: `Pattern rejected: ${securityCheck.warnings.join(', ')}`
+                };
+            }
+            // Execute in Web Worker with timeout
+            const result = await this.executeInWorker(pattern, text, finalConfig);
+            return {
+                ...result,
+                executionTime: performance.now() - startTime
+            };
+        }
+        catch (error) {
+            return {
+                match: false,
+                executionTime: performance.now() - startTime,
+                timeout: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Analyzes the security of a regular expression pattern
+     */
+    async analyzePatternSecurity(pattern) {
+        const warnings = [];
+        const recommendations = [];
+        let complexity = 0;
+        let risk = 'low';
+        // Analysis of dangerous patterns
+        const dangerousPatterns = [
+            { pattern: /\*\*/, risk: 'high', message: 'Nested quantifiers (catastrophic backtracking)' },
+            { pattern: /\+\+/, risk: 'high', message: 'Nested plus quantifiers' },
+            { pattern: /\(\?\=/, risk: 'medium', message: 'Lookahead assertions' },
+            { pattern: /\(\?\!/, risk: 'medium', message: 'Negative lookahead' },
+            { pattern: /\(\?\:/, risk: 'low', message: 'Non-capturing groups' },
+            { pattern: /\(\?\</, risk: 'high', message: 'Lookbehind assertions' },
+            { pattern: /\(\?\(\?\)/, risk: 'critical', message: 'Recursive patterns' },
+            { pattern: /(\{(\d+,)?\d+\})/, risk: 'medium', message: 'Quantified repetition' },
+            { pattern: /(\.\*)|(\.+)|(\.\?)/, risk: 'medium', message: 'Greedy quantifiers with dot' },
+            { pattern: /(\[.*\*.*\])|(\[.*\+.*\])/, risk: 'medium', message: 'Character classes with quantifiers' }
+        ];
+        // Calculate complexity
+        complexity = this.calculateComplexity(pattern);
+        // Evaluate dangerous patterns
+        for (const dangerous of dangerousPatterns) {
+            if (dangerous.pattern.test(pattern)) {
+                warnings.push(dangerous.message);
+                if (this.getRiskLevel(dangerous.risk) > this.getRiskLevel(risk)) {
+                    risk = dangerous.risk;
+                }
+            }
+        }
+        // Recommendations based on the analysis
+        if (complexity > 10) {
+            recommendations.push('Consider simplifying the pattern');
+            risk = this.getRiskLevel(risk) > this.getRiskLevel('high') ? risk : 'high';
+        }
+        if (pattern.includes('**') || pattern.includes('++')) {
+            recommendations.push('Avoid nested quantifiers to prevent catastrophic backtracking');
+        }
+        if (pattern.length > 100) {
+            recommendations.push('Long patterns are harder to maintain and may impact performance');
+        }
+        const safe = risk !== 'critical' && warnings.length === 0;
+        return {
+            safe,
+            complexity,
+            risk,
+            warnings,
+            recommendations
+        };
+    }
+    /**
+     * Executes the regular expression in a Web Worker
+     */
+    async executeInWorker(pattern, text, config) {
+        return new Promise((resolve) => {
+            const workerName = `regex-worker-${Date.now()}`;
+            try {
+                // Create temporary worker
+                const workerCode = this.generateWorkerCode();
+                const blob = new Blob([workerCode], { type: 'application/javascript' });
+                const worker = new Worker(URL.createObjectURL(blob));
+                this.workers.set(workerName, worker);
+                const taskId = `regex_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                const task = {
+                    id: taskId,
+                    type: 'regex-test',
+                    data: {
+                        pattern,
+                        text,
+                        timeout: config.timeout || 5000
+                    }
+                };
+                // Timeout for execution
+                const timeoutId = setTimeout(() => {
+                    worker.terminate();
+                    this.workers.delete(workerName);
+                    resolve({
+                        match: false,
+                        executionTime: 0,
+                        timeout: true,
+                        error: 'Execution timeout'
+                    });
+                }, config.timeout || 5000);
+                worker.onmessage = (event) => {
+                    clearTimeout(timeoutId);
+                    worker.terminate();
+                    this.workers.delete(workerName);
+                    if (event.data.id === taskId) {
+                        resolve(event.data.data);
+                    }
+                };
+                worker.onerror = (error) => {
+                    clearTimeout(timeoutId);
+                    worker.terminate();
+                    this.workers.delete(workerName);
+                    resolve({
+                        match: false,
+                        executionTime: 0,
+                        timeout: false,
+                        error: `Worker error: ${error.message || 'Unknown error'}`
+                    });
+                };
+                worker.postMessage(task);
+            }
+            catch (error) {
+                resolve({
+                    match: false,
+                    executionTime: 0,
+                    timeout: false,
+                    error: `Failed to create worker: ${error instanceof Error ? error.message : 'Unknown error'}`
+                });
+            }
+        });
+    }
+    /**
+     * Generates the Web Worker code
+     */
+    generateWorkerCode() {
+        return `
+      self.addEventListener('message', function(event) {
+        const task = event.data;
+        
+        if (task.type === 'regex-test') {
+          const { pattern, text, timeout } = task.data;
+          const startTime = performance.now();
+          
+          try {
+            const regex = new RegExp(pattern, 'g');
+            const matches = [];
+            let match;
+            
+            while ((match = regex.exec(text)) !== null) {
+              matches.push([...match]);
+              
+              // Prevention of infinite loops
+              if (matches.length > 1000) {
+                throw new Error('Too many matches - possible infinite loop');
+              }
+            }
+            
+            const groups = {};
+            if (matches.length > 0) {
+              const firstMatch = matches[0];
+              for (let i = 1; i < firstMatch.length; i++) {
+                groups[\`group\${i}\`] = firstMatch[i];
+              }
+            }
+            
+            self.postMessage({
+              id: task.id,
+              type: 'regex-result',
+              data: {
+                match: matches.length > 0,
+                matches,
+                groups,
+                executionTime: performance.now() - startTime,
+                timeout: false
+              }
+            });
+          } catch (error) {
+            self.postMessage({
+              id: task.id,
+              type: 'regex-result',
+              data: {
+                match: false,
+                executionTime: performance.now() - startTime,
+                timeout: false,
+                error: error.message || 'Execution error'
+              }
+            });
+          }
+        }
+      });
+    `;
+    }
+    /**
+     * Calculates the complexity of a pattern
+     */
+    calculateComplexity(pattern) {
+        let complexity = 0;
+        // Nested quantifiers increase complexity
+        complexity += (pattern.match(/\*\*/g) || []).length * 5;
+        complexity += (pattern.match(/\+\+/g) || []).length * 5;
+        complexity += (pattern.match(/\?\?/g) || []).length * 3;
+        // Lookaheads/lookbehinds
+        complexity += (pattern.match(/\(\?\=/g) || []).length * 2;
+        complexity += (pattern.match(/\(\?\!/g) || []).length * 2;
+        complexity += (pattern.match(/\(\?\</g) || []).length * 3;
+        // Nested groups
+        const openParens = (pattern.match(/\(/g) || []).length;
+        complexity += openParens * 0.5;
+        // Pattern length
+        complexity += pattern.length * 0.01;
+        return Math.round(complexity * 100) / 100;
+    }
+    /**
+     * Gets numeric risk level
+     */
+    getRiskLevel(risk) {
+        const levels = { 'low': 1, 'medium': 2, 'high': 3, 'critical': 4 };
+        return levels[risk] || 0;
+    }
+    /**
+     * Merges configuration with default values
+     */
+    mergeConfig(config) {
+        return {
+            timeout: config.timeout || 5000,
+            maxComplexity: config.maxComplexity || 10,
+            allowBacktracking: config.allowBacktracking || false,
+            safeMode: config.safeMode || false
+        };
+    }
+    /**
+     * Cleans up resources when the service is destroyed
+     */
+    ngOnDestroy() {
+        this.workers.forEach(worker => {
+            worker.terminate();
+        });
+        this.workers.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RegexSecurityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RegexSecurityService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RegexSecurityService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Builder pattern to construct safe regular expressions
+ */
+class RegexSecurityBuilder {
+    patternValue = '';
+    optionsValue = {};
+    securityConfigValue = {};
+    /**
+     * Defines the base pattern
+     */
+    pattern(pattern) {
+        this.patternValue = pattern;
+        return this;
+    }
+    /**
+     * Appends text to the current pattern
+     */
+    append(text) {
+        this.patternValue += text;
+        return this;
+    }
+    /**
+     * Adds a capturing group
+     */
+    group(content, name) {
+        if (name) {
+            this.patternValue += `(?<${name}>${content})`;
+        }
+        else {
+            this.patternValue += `(${content})`;
+        }
+        return this;
+    }
+    /**
+     * Adds a non-capturing group
+     */
+    nonCapturingGroup(content) {
+        this.patternValue += `(?:${content})`;
+        return this;
+    }
+    /**
+     * Adds an alternative
+     */
+    or(alternative) {
+        this.patternValue += `|${alternative}`;
+        return this;
+    }
+    /**
+     * Adds a quantifier
+     */
+    quantifier(quantifier) {
+        this.patternValue += quantifier;
+        return this;
+    }
+    /**
+     * Adds a character set
+     */
+    characterSet(chars, negate = false) {
+        this.patternValue += `[${negate ? '^' : ''}${chars}]`;
+        return this;
+    }
+    /**
+     * Adds a start of line anchor
+     */
+    startOfLine() {
+        this.patternValue += '^';
+        return this;
+    }
+    /**
+     * Adds an end of line anchor
+     */
+    endOfLine() {
+        this.patternValue += '$';
+        return this;
+    }
+    /**
+     * Configures regular expression options
+     */
+    options(options) {
+        this.optionsValue = { ...this.optionsValue, ...options };
+        return this;
+    }
+    /**
+     * Configures security options
+     */
+    security(config) {
+        this.securityConfigValue = { ...this.securityConfigValue, ...config };
+        return this;
+    }
+    /**
+     * Configures timeout
+     */
+    timeout(ms) {
+        this.securityConfigValue.timeout = ms;
+        return this;
+    }
+    /**
+     * Activates safe mode
+     */
+    safeMode() {
+        this.securityConfigValue.safeMode = true;
+        return this;
+    }
+    /**
+     * Builds the final regular expression
+     */
+    build() {
+        return {
+            pattern: this.patternValue,
+            options: this.optionsValue,
+            security: this.securityConfigValue
+        };
+    }
+    /**
+     * Builds and executes the regular expression
+     */
+    async execute(text, service) {
+        const { pattern, security } = this.build();
+        return service.testRegex(pattern, text, security);
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { RegexSecurityBuilder, RegexSecurityService };
+//# sourceMappingURL=angular-helpers-security.mjs.map

package/fesm2022/angular-helpers-security.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-helpers-security.mjs","sources":["../../../packages/security/src/services/regex-security.service.ts","../../../packages/security/src/angular-helpers-security.ts"],"sourcesContent":["import { Injectable, inject, DestroyRef } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { map, catchError, timeout } from 'rxjs/operators';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nexport interface RegexSecurityConfig {\n  timeout?: number; // Timeout in milliseconds (default: 5000)\n  maxComplexity?: number; // Maximum complexity allowed\n  allowBacktracking?: boolean; // Allow catastrophic backtracking\n  safeMode?: boolean; // Safe mode with secure patterns only\n}\n\nexport interface RegexTestResult {\n  match: boolean;\n  matches?: RegExpMatchArray[];\n  groups?: { [key: string]: string };\n  executionTime: number;\n  timeout: boolean;\n  error?: string;\n}\n\nexport interface RegexSecurityResult {\n  safe: boolean;\n  complexity: number;\n  risk: 'low' | 'medium' | 'high' | 'critical';\n  warnings: string[];\n  recommendations: string[];\n}\n\nexport interface RegexBuilderOptions {\n  global?: boolean;\n  ignoreCase?: boolean;\n  multiline?: boolean;\n  dotAll?: boolean;\n  unicode?: boolean;\n  sticky?: boolean;\n}\n\n/**\n * Security service for regular expressions that prevents ReDoS\n * using Web Workers for safe execution with timeout\n */\n@Injectable()\nexport class RegexSecurityService {\n  private destroyRef = inject(DestroyRef);\n  private workers = new Map<string, Worker>();\n\n  /**\n   * Builder pattern to construct safe regular expressions\n   */\n  static builder(): RegexSecurityBuilder {\n    return new RegexSecurityBuilder();\n  }\n\n  /**\n   * Executes a regular expression safely with a timeout\n   */\n  async testRegex(\n    pattern: string,\n    text: string,\n    config: RegexSecurityConfig = {}\n  ): Promise<RegexTestResult> {\n    const startTime = performance.now();\n    const finalConfig = this.mergeConfig(config);\n\n    try {\n      // First, analyze pattern security\n      const securityCheck = await this.analyzePatternSecurity(pattern);\n      \n      if (!securityCheck.safe && !finalConfig.safeMode) {\n        return {\n          match: false,\n          executionTime: performance.now() - startTime,\n          timeout: false,\n          error: `Pattern rejected: ${securityCheck.warnings.join(', ')}`\n        };\n      }\n\n      // Execute in Web Worker with timeout\n      const result = await this.executeInWorker(pattern, text, finalConfig);\n      \n      return {\n        ...result,\n        executionTime: performance.now() - startTime\n      };\n    } catch (error) {\n      return {\n        match: false,\n        executionTime: performance.now() - startTime,\n        timeout: false,\n        error: error instanceof Error ? error.message : 'Unknown error'\n      };\n    }\n  }\n\n  /**\n   * Analyzes the security of a regular expression pattern\n   */\n  async analyzePatternSecurity(pattern: string): Promise<RegexSecurityResult> {\n    const warnings: string[] = [];\n    const recommendations: string[] = [];\n    let complexity = 0;\n    let risk: 'low' | 'medium' | 'high' | 'critical' = 'low';\n\n    // Analysis of dangerous patterns\n    const dangerousPatterns = [\n      { pattern: /\\*\\*/, risk: 'high' as const, message: 'Nested quantifiers (catastrophic backtracking)' },\n      { pattern: /\\+\\+/, risk: 'high' as const, message: 'Nested plus quantifiers' },\n      { pattern: /\\(\\?\\=/, risk: 'medium' as const, message: 'Lookahead assertions' },\n      { pattern: /\\(\\?\\!/, risk: 'medium' as const, message: 'Negative lookahead' },\n      { pattern: /\\(\\?\\:/, risk: 'low' as const, message: 'Non-capturing groups' },\n      { pattern: /\\(\\?\\</, risk: 'high' as const, message: 'Lookbehind assertions' },\n      { pattern: /\\(\\?\\(\\?\\)/, risk: 'critical' as const, message: 'Recursive patterns' },\n      { pattern: /(\\{(\\d+,)?\\d+\\})/, risk: 'medium' as const, message: 'Quantified repetition' },\n      { pattern: /(\\.\\*)|(\\.+)|(\\.\\?)/, risk: 'medium' as const, message: 'Greedy quantifiers with dot' },\n      { pattern: /(\\[.*\\*.*\\])|(\\[.*\\+.*\\])/, risk: 'medium' as const, message: 'Character classes with quantifiers' }\n    ];\n\n    // Calculate complexity\n    complexity = this.calculateComplexity(pattern);\n\n    // Evaluate dangerous patterns\n    for (const dangerous of dangerousPatterns) {\n      if (dangerous.pattern.test(pattern)) {\n        warnings.push(dangerous.message);\n        if (this.getRiskLevel(dangerous.risk) > this.getRiskLevel(risk)) {\n          risk = dangerous.risk;\n        }\n      }\n    }\n\n    // Recommendations based on the analysis\n    if (complexity > 10) {\n      recommendations.push('Consider simplifying the pattern');\n      risk = this.getRiskLevel(risk) > this.getRiskLevel('high') ? risk : 'high';\n    }\n\n    if (pattern.includes('**') || pattern.includes('++')) {\n      recommendations.push('Avoid nested quantifiers to prevent catastrophic backtracking');\n    }\n\n    if (pattern.length > 100) {\n      recommendations.push('Long patterns are harder to maintain and may impact performance');\n    }\n\n    const safe = risk !== 'critical' && warnings.length === 0;\n\n    return {\n      safe,\n      complexity,\n      risk,\n      warnings,\n      recommendations\n    };\n  }\n\n  /**\n   * Executes the regular expression in a Web Worker\n   */\n  private async executeInWorker(\n    pattern: string,\n    text: string,\n    config: RegexSecurityConfig\n  ): Promise<RegexTestResult> {\n    return new Promise((resolve) => {\n      const workerName = `regex-worker-${Date.now()}`;\n      \n      try {\n        // Create temporary worker\n        const workerCode = this.generateWorkerCode();\n        const blob = new Blob([workerCode], { type: 'application/javascript' });\n        const worker = new Worker(URL.createObjectURL(blob));\n        \n        this.workers.set(workerName, worker);\n\n        const taskId = `regex_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n        \n        const task = {\n          id: taskId,\n          type: 'regex-test',\n          data: {\n            pattern,\n            text,\n            timeout: config.timeout || 5000\n          }\n        };\n\n        // Timeout for execution\n        const timeoutId = setTimeout(() => {\n          worker.terminate();\n          this.workers.delete(workerName);\n          resolve({\n            match: false,\n            executionTime: 0,\n            timeout: true,\n            error: 'Execution timeout'\n          });\n        }, config.timeout || 5000);\n\n        worker.onmessage = (event) => {\n          clearTimeout(timeoutId);\n          worker.terminate();\n          this.workers.delete(workerName);\n          \n          if (event.data.id === taskId) {\n            resolve(event.data.data as RegexTestResult);\n          }\n        };\n\n        worker.onerror = (error) => {\n          clearTimeout(timeoutId);\n          worker.terminate();\n          this.workers.delete(workerName);\n          resolve({\n            match: false,\n            executionTime: 0,\n            timeout: false,\n            error: `Worker error: ${error.message || 'Unknown error'}`\n          });\n        };\n\n        worker.postMessage(task);\n      } catch (error) {\n        resolve({\n          match: false,\n          executionTime: 0,\n          timeout: false,\n          error: `Failed to create worker: ${error instanceof Error ? error.message : 'Unknown error'}`\n        });\n      }\n    });\n  }\n\n  /**\n   * Generates the Web Worker code\n   */\n  private generateWorkerCode(): string {\n    return `\n      self.addEventListener('message', function(event) {\n        const task = event.data;\n        \n        if (task.type === 'regex-test') {\n          const { pattern, text, timeout } = task.data;\n          const startTime = performance.now();\n          \n          try {\n            const regex = new RegExp(pattern, 'g');\n            const matches = [];\n            let match;\n            \n            while ((match = regex.exec(text)) !== null) {\n              matches.push([...match]);\n              \n              // Prevention of infinite loops\n              if (matches.length > 1000) {\n                throw new Error('Too many matches - possible infinite loop');\n              }\n            }\n            \n            const groups = {};\n            if (matches.length > 0) {\n              const firstMatch = matches[0];\n              for (let i = 1; i < firstMatch.length; i++) {\n                groups[\\`group\\${i}\\`] = firstMatch[i];\n              }\n            }\n            \n            self.postMessage({\n              id: task.id,\n              type: 'regex-result',\n              data: {\n                match: matches.length > 0,\n                matches,\n                groups,\n                executionTime: performance.now() - startTime,\n                timeout: false\n              }\n            });\n          } catch (error) {\n            self.postMessage({\n              id: task.id,\n              type: 'regex-result',\n              data: {\n                match: false,\n                executionTime: performance.now() - startTime,\n                timeout: false,\n                error: error.message || 'Execution error'\n              }\n            });\n          }\n        }\n      });\n    `;\n  }\n\n  /**\n   * Calculates the complexity of a pattern\n   */\n  private calculateComplexity(pattern: string): number {\n    let complexity = 0;\n    \n    // Nested quantifiers increase complexity\n    complexity += (pattern.match(/\\*\\*/g) || []).length * 5;\n    complexity += (pattern.match(/\\+\\+/g) || []).length * 5;\n    complexity += (pattern.match(/\\?\\?/g) || []).length * 3;\n    \n    // Lookaheads/lookbehinds\n    complexity += (pattern.match(/\\(\\?\\=/g) || []).length * 2;\n    complexity += (pattern.match(/\\(\\?\\!/g) || []).length * 2;\n    complexity += (pattern.match(/\\(\\?\\</g) || []).length * 3;\n    \n    // Nested groups\n    const openParens = (pattern.match(/\\(/g) || []).length;\n    complexity += openParens * 0.5;\n    \n    // Pattern length\n    complexity += pattern.length * 0.01;\n    \n    return Math.round(complexity * 100) / 100;\n  }\n\n  /**\n   * Gets numeric risk level\n   */\n  private getRiskLevel(risk: 'low' | 'medium' | 'high' | 'critical'): number {\n    const levels = { 'low': 1, 'medium': 2, 'high': 3, 'critical': 4 };\n    return levels[risk] || 0;\n  }\n\n  /**\n   * Merges configuration with default values\n   */\n  private mergeConfig(config: RegexSecurityConfig): Required<RegexSecurityConfig> {\n    return {\n      timeout: config.timeout || 5000,\n      maxComplexity: config.maxComplexity || 10,\n      allowBacktracking: config.allowBacktracking || false,\n      safeMode: config.safeMode || false\n    };\n  }\n\n  /**\n   * Cleans up resources when the service is destroyed\n   */\n  ngOnDestroy(): void {\n    this.workers.forEach(worker => {\n      worker.terminate();\n    });\n    this.workers.clear();\n  }\n}\n\n/**\n * Builder pattern to construct safe regular expressions\n */\nexport class RegexSecurityBuilder {\n  private patternValue: string = '';\n  private optionsValue: RegexBuilderOptions = {};\n  private securityConfigValue: RegexSecurityConfig = {};\n\n  /**\n   * Defines the base pattern\n   */\n  pattern(pattern: string): RegexSecurityBuilder {\n    this.patternValue = pattern;\n    return this;\n  }\n\n  /**\n   * Appends text to the current pattern\n   */\n  append(text: string): RegexSecurityBuilder {\n    this.patternValue += text;\n    return this;\n  }\n\n  /**\n   * Adds a capturing group\n   */\n  group(content: string, name?: string): RegexSecurityBuilder {\n    if (name) {\n      this.patternValue += `(?<${name}>${content})`;\n    } else {\n      this.patternValue += `(${content})`;\n    }\n    return this;\n  }\n\n  /**\n   * Adds a non-capturing group\n   */\n  nonCapturingGroup(content: string): RegexSecurityBuilder {\n    this.patternValue += `(?:${content})`;\n    return this;\n  }\n\n  /**\n   * Adds an alternative\n   */\n  or(alternative: string): RegexSecurityBuilder {\n    this.patternValue += `|${alternative}`;\n    return this;\n  }\n\n  /**\n   * Adds a quantifier\n   */\n  quantifier(quantifier: '*' | '+' | '?' | '{n}' | '{n,}' | '{n,m}'): RegexSecurityBuilder {\n    this.patternValue += quantifier;\n    return this;\n  }\n\n  /**\n   * Adds a character set\n   */\n  characterSet(chars: string, negate = false): RegexSecurityBuilder {\n    this.patternValue += `[${negate ? '^' : ''}${chars}]`;\n    return this;\n  }\n\n  /**\n   * Adds a start of line anchor\n   */\n  startOfLine(): RegexSecurityBuilder {\n    this.patternValue += '^';\n    return this;\n  }\n\n  /**\n   * Adds an end of line anchor\n   */\n  endOfLine(): RegexSecurityBuilder {\n    this.patternValue += '$';\n    return this;\n  }\n\n  /**\n   * Configures regular expression options\n   */\n  options(options: RegexBuilderOptions): RegexSecurityBuilder {\n    this.optionsValue = { ...this.optionsValue, ...options };\n    return this;\n  }\n\n  /**\n   * Configures security options\n   */\n  security(config: RegexSecurityConfig): RegexSecurityBuilder {\n    this.securityConfigValue = { ...this.securityConfigValue, ...config };\n    return this;\n  }\n\n  /**\n   * Configures timeout\n   */\n  timeout(ms: number): RegexSecurityBuilder {\n    this.securityConfigValue.timeout = ms;\n    return this;\n  }\n\n  /**\n   * Activates safe mode\n   */\n  safeMode(): RegexSecurityBuilder {\n    this.securityConfigValue.safeMode = true;\n    return this;\n  }\n\n  /**\n   * Builds the final regular expression\n   */\n  build(): { pattern: string; options: RegexBuilderOptions; security: RegexSecurityConfig } {\n    return {\n      pattern: this.patternValue,\n      options: this.optionsValue,\n      security: this.securityConfigValue\n    };\n  }\n\n  /**\n   * Builds and executes the regular expression\n   */\n  async execute(text: string, service: RegexSecurityService): Promise<RegexTestResult> {\n    const { pattern, security } = this.build();\n    return service.testRegex(pattern, text, security);\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/security",
-  "version": "21.0.0",
+  "version": "21.0.2",
   "description": "Angular security helpers for preventing ReDoS and other security vulnerabilities",
   "keywords": [
     "angular",
@@ -24,26 +24,25 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "ng-packagr -p ng-package.json"
-  },
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0",
-    "@angular-helpers/browser-web-apis": "21.0.0",
-    "rxjs": "^7.0.0 || ^8.0.0",
-    "tslib": "^2.0.0"
+    "@angular-helpers/browser-web-apis": "21.0.2",
+    "rxjs": "^7.0.0 || ^8.0.0"
   },
   "dependencies": {
     "tslib": "^2.0.0"
   },
-  "ngPackage": {
-    "lib": {
-      "entryFile": "src/index.ts"
+  "module": "fesm2022/angular-helpers-security.mjs",
+  "typings": "types/angular-helpers-security.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
     },
-    "dest": "../../dist/security",
-    "allowedNonPeerDependencies": [
-      "tslib"
-    ]
-  }
-}
+    ".": {
+      "types": "./types/angular-helpers-security.d.ts",
+      "default": "./fesm2022/angular-helpers-security.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/types/angular-helpers-security.d.ts

@@ -0,0 +1,154 @@
+import * as i0 from '@angular/core';
+
+interface RegexSecurityConfig {
+    timeout?: number;
+    maxComplexity?: number;
+    allowBacktracking?: boolean;
+    safeMode?: boolean;
+}
+interface RegexTestResult {
+    match: boolean;
+    matches?: RegExpMatchArray[];
+    groups?: {
+        [key: string]: string;
+    };
+    executionTime: number;
+    timeout: boolean;
+    error?: string;
+}
+interface RegexSecurityResult {
+    safe: boolean;
+    complexity: number;
+    risk: 'low' | 'medium' | 'high' | 'critical';
+    warnings: string[];
+    recommendations: string[];
+}
+interface RegexBuilderOptions {
+    global?: boolean;
+    ignoreCase?: boolean;
+    multiline?: boolean;
+    dotAll?: boolean;
+    unicode?: boolean;
+    sticky?: boolean;
+}
+/**
+ * Security service for regular expressions that prevents ReDoS
+ * using Web Workers for safe execution with timeout
+ */
+declare class RegexSecurityService {
+    private destroyRef;
+    private workers;
+    /**
+     * Builder pattern to construct safe regular expressions
+     */
+    static builder(): RegexSecurityBuilder;
+    /**
+     * Executes a regular expression safely with a timeout
+     */
+    testRegex(pattern: string, text: string, config?: RegexSecurityConfig): Promise<RegexTestResult>;
+    /**
+     * Analyzes the security of a regular expression pattern
+     */
+    analyzePatternSecurity(pattern: string): Promise<RegexSecurityResult>;
+    /**
+     * Executes the regular expression in a Web Worker
+     */
+    private executeInWorker;
+    /**
+     * Generates the Web Worker code
+     */
+    private generateWorkerCode;
+    /**
+     * Calculates the complexity of a pattern
+     */
+    private calculateComplexity;
+    /**
+     * Gets numeric risk level
+     */
+    private getRiskLevel;
+    /**
+     * Merges configuration with default values
+     */
+    private mergeConfig;
+    /**
+     * Cleans up resources when the service is destroyed
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegexSecurityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegexSecurityService>;
+}
+/**
+ * Builder pattern to construct safe regular expressions
+ */
+declare class RegexSecurityBuilder {
+    private patternValue;
+    private optionsValue;
+    private securityConfigValue;
+    /**
+     * Defines the base pattern
+     */
+    pattern(pattern: string): RegexSecurityBuilder;
+    /**
+     * Appends text to the current pattern
+     */
+    append(text: string): RegexSecurityBuilder;
+    /**
+     * Adds a capturing group
+     */
+    group(content: string, name?: string): RegexSecurityBuilder;
+    /**
+     * Adds a non-capturing group
+     */
+    nonCapturingGroup(content: string): RegexSecurityBuilder;
+    /**
+     * Adds an alternative
+     */
+    or(alternative: string): RegexSecurityBuilder;
+    /**
+     * Adds a quantifier
+     */
+    quantifier(quantifier: '*' | '+' | '?' | '{n}' | '{n,}' | '{n,m}'): RegexSecurityBuilder;
+    /**
+     * Adds a character set
+     */
+    characterSet(chars: string, negate?: boolean): RegexSecurityBuilder;
+    /**
+     * Adds a start of line anchor
+     */
+    startOfLine(): RegexSecurityBuilder;
+    /**
+     * Adds an end of line anchor
+     */
+    endOfLine(): RegexSecurityBuilder;
+    /**
+     * Configures regular expression options
+     */
+    options(options: RegexBuilderOptions): RegexSecurityBuilder;
+    /**
+     * Configures security options
+     */
+    security(config: RegexSecurityConfig): RegexSecurityBuilder;
+    /**
+     * Configures timeout
+     */
+    timeout(ms: number): RegexSecurityBuilder;
+    /**
+     * Activates safe mode
+     */
+    safeMode(): RegexSecurityBuilder;
+    /**
+     * Builds the final regular expression
+     */
+    build(): {
+        pattern: string;
+        options: RegexBuilderOptions;
+        security: RegexSecurityConfig;
+    };
+    /**
+     * Builds and executes the regular expression
+     */
+    execute(text: string, service: RegexSecurityService): Promise<RegexTestResult>;
+}
+
+export { RegexSecurityBuilder, RegexSecurityService };
+export type { RegexBuilderOptions, RegexSecurityConfig, RegexSecurityResult, RegexTestResult };

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
-  "lib": {
-    "entryFile": "src/index.ts"
-  },
-  "dest": "../../dist/security"
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './services/regex-security.service';

package/src/interfaces/security.interface.ts

@@ -1,32 +0,0 @@
-export interface RegexSecurityConfig {
-  timeout?: number; // Timeout en milisegundos (default: 5000)
-  maxComplexity?: number; // Máxima complejidad permitida
-  allowBacktracking?: boolean; // Permitir backtracking catastrófico
-  safeMode?: boolean; // Modo seguro solo con patrones seguros
-}
-
-export interface RegexTestResult {
-  match: boolean;
-  matches?: RegExpMatchArray[];
-  groups?: { [key: string]: string };
-  executionTime: number;
-  timeout: boolean;
-  error?: string;
-}
-
-export interface RegexSecurityResult {
-  safe: boolean;
-  complexity: number;
-  risk: 'low' | 'medium' | 'high' | 'critical';
-  warnings: string[];
-  recommendations: string[];
-}
-
-export interface RegexBuilderOptions {
-  global?: boolean;
-  ignoreCase?: boolean;
-  multiline?: boolean;
-  dotAll?: boolean;
-  unicode?: boolean;
-  sticky?: boolean;
-}

package/src/providers.ts

@@ -1,29 +0,0 @@
-import { makeEnvironmentProviders, EnvironmentProviders } from '@angular/core';
-import { RegexSecurityService } from './services/regex-security.service';
-
-export interface SecurityConfig {
-  enableRegexSecurity?: boolean;
-  defaultTimeout?: number;
-  safeMode?: boolean;
-}
-
-export const defaultSecurityConfig: SecurityConfig = {
-  enableRegexSecurity: true,
-  defaultTimeout: 5000,
-  safeMode: false
-};
-
-export function provideSecurity(config: SecurityConfig = {}): EnvironmentProviders {
-  const mergedConfig = { ...defaultSecurityConfig, ...config };
-  const providers = [];
-  
-  if (mergedConfig.enableRegexSecurity) {
-    providers.push(RegexSecurityService);
-  }
-  
-  return makeEnvironmentProviders(providers);
-}
-
-export function provideRegexSecurity(): EnvironmentProviders {
-  return makeEnvironmentProviders([RegexSecurityService]);
-}

package/src/services/regex-security.service.ts

@@ -1,487 +0,0 @@
-import { Injectable, inject, DestroyRef } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
-import { map, catchError, timeout } from 'rxjs/operators';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-
-export interface RegexSecurityConfig {
-  timeout?: number; // Timeout in milliseconds (default: 5000)
-  maxComplexity?: number; // Maximum complexity allowed
-  allowBacktracking?: boolean; // Allow catastrophic backtracking
-  safeMode?: boolean; // Safe mode with secure patterns only
-}
-
-export interface RegexTestResult {
-  match: boolean;
-  matches?: RegExpMatchArray[];
-  groups?: { [key: string]: string };
-  executionTime: number;
-  timeout: boolean;
-  error?: string;
-}
-
-export interface RegexSecurityResult {
-  safe: boolean;
-  complexity: number;
-  risk: 'low' | 'medium' | 'high' | 'critical';
-  warnings: string[];
-  recommendations: string[];
-}
-
-export interface RegexBuilderOptions {
-  global?: boolean;
-  ignoreCase?: boolean;
-  multiline?: boolean;
-  dotAll?: boolean;
-  unicode?: boolean;
-  sticky?: boolean;
-}
-
-/**
- * Security service for regular expressions that prevents ReDoS
- * using Web Workers for safe execution with timeout
- */
-@Injectable()
-export class RegexSecurityService {
-  private destroyRef = inject(DestroyRef);
-  private workers = new Map<string, Worker>();
-
-  /**
-   * Builder pattern to construct safe regular expressions
-   */
-  static builder(): RegexSecurityBuilder {
-    return new RegexSecurityBuilder();
-  }
-
-  /**
-   * Executes a regular expression safely with a timeout
-   */
-  async testRegex(
-    pattern: string,
-    text: string,
-    config: RegexSecurityConfig = {}
-  ): Promise<RegexTestResult> {
-    const startTime = performance.now();
-    const finalConfig = this.mergeConfig(config);
-
-    try {
-      // First, analyze pattern security
-      const securityCheck = await this.analyzePatternSecurity(pattern);
-      
-      if (!securityCheck.safe && !finalConfig.safeMode) {
-        return {
-          match: false,
-          executionTime: performance.now() - startTime,
-          timeout: false,
-          error: `Pattern rejected: ${securityCheck.warnings.join(', ')}`
-        };
-      }
-
-      // Execute in Web Worker with timeout
-      const result = await this.executeInWorker(pattern, text, finalConfig);
-      
-      return {
-        ...result,
-        executionTime: performance.now() - startTime
-      };
-    } catch (error) {
-      return {
-        match: false,
-        executionTime: performance.now() - startTime,
-        timeout: false,
-        error: error instanceof Error ? error.message : 'Unknown error'
-      };
-    }
-  }
-
-  /**
-   * Analyzes the security of a regular expression pattern
-   */
-  async analyzePatternSecurity(pattern: string): Promise<RegexSecurityResult> {
-    const warnings: string[] = [];
-    const recommendations: string[] = [];
-    let complexity = 0;
-    let risk: 'low' | 'medium' | 'high' | 'critical' = 'low';
-
-    // Analysis of dangerous patterns
-    const dangerousPatterns = [
-      { pattern: /\*\*/, risk: 'high' as const, message: 'Nested quantifiers (catastrophic backtracking)' },
-      { pattern: /\+\+/, risk: 'high' as const, message: 'Nested plus quantifiers' },
-      { pattern: /\(\?\=/, risk: 'medium' as const, message: 'Lookahead assertions' },
-      { pattern: /\(\?\!/, risk: 'medium' as const, message: 'Negative lookahead' },
-      { pattern: /\(\?\:/, risk: 'low' as const, message: 'Non-capturing groups' },
-      { pattern: /\(\?\</, risk: 'high' as const, message: 'Lookbehind assertions' },
-      { pattern: /\(\?\(\?\)/, risk: 'critical' as const, message: 'Recursive patterns' },
-      { pattern: /(\{(\d+,)?\d+\})/, risk: 'medium' as const, message: 'Quantified repetition' },
-      { pattern: /(\.\*)|(\.+)|(\.\?)/, risk: 'medium' as const, message: 'Greedy quantifiers with dot' },
-      { pattern: /(\[.*\*.*\])|(\[.*\+.*\])/, risk: 'medium' as const, message: 'Character classes with quantifiers' }
-    ];
-
-    // Calculate complexity
-    complexity = this.calculateComplexity(pattern);
-
-    // Evaluate dangerous patterns
-    for (const dangerous of dangerousPatterns) {
-      if (dangerous.pattern.test(pattern)) {
-        warnings.push(dangerous.message);
-        if (this.getRiskLevel(dangerous.risk) > this.getRiskLevel(risk)) {
-          risk = dangerous.risk;
-        }
-      }
-    }
-
-    // Recommendations based on the analysis
-    if (complexity > 10) {
-      recommendations.push('Consider simplifying the pattern');
-      risk = this.getRiskLevel(risk) > this.getRiskLevel('high') ? risk : 'high';
-    }
-
-    if (pattern.includes('**') || pattern.includes('++')) {
-      recommendations.push('Avoid nested quantifiers to prevent catastrophic backtracking');
-    }
-
-    if (pattern.length > 100) {
-      recommendations.push('Long patterns are harder to maintain and may impact performance');
-    }
-
-    const safe = risk !== 'critical' && warnings.length === 0;
-
-    return {
-      safe,
-      complexity,
-      risk,
-      warnings,
-      recommendations
-    };
-  }
-
-  /**
-   * Executes the regular expression in a Web Worker
-   */
-  private async executeInWorker(
-    pattern: string,
-    text: string,
-    config: RegexSecurityConfig
-  ): Promise<RegexTestResult> {
-    return new Promise((resolve) => {
-      const workerName = `regex-worker-${Date.now()}`;
-      
-      try {
-        // Create temporary worker
-        const workerCode = this.generateWorkerCode();
-        const blob = new Blob([workerCode], { type: 'application/javascript' });
-        const worker = new Worker(URL.createObjectURL(blob));
-        
-        this.workers.set(workerName, worker);
-
-        const taskId = `regex_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        
-        const task = {
-          id: taskId,
-          type: 'regex-test',
-          data: {
-            pattern,
-            text,
-            timeout: config.timeout || 5000
-          }
-        };
-
-        // Timeout for execution
-        const timeoutId = setTimeout(() => {
-          worker.terminate();
-          this.workers.delete(workerName);
-          resolve({
-            match: false,
-            executionTime: 0,
-            timeout: true,
-            error: 'Execution timeout'
-          });
-        }, config.timeout || 5000);
-
-        worker.onmessage = (event) => {
-          clearTimeout(timeoutId);
-          worker.terminate();
-          this.workers.delete(workerName);
-          
-          if (event.data.id === taskId) {
-            resolve(event.data.data as RegexTestResult);
-          }
-        };
-
-        worker.onerror = (error) => {
-          clearTimeout(timeoutId);
-          worker.terminate();
-          this.workers.delete(workerName);
-          resolve({
-            match: false,
-            executionTime: 0,
-            timeout: false,
-            error: `Worker error: ${error.message || 'Unknown error'}`
-          });
-        };
-
-        worker.postMessage(task);
-      } catch (error) {
-        resolve({
-          match: false,
-          executionTime: 0,
-          timeout: false,
-          error: `Failed to create worker: ${error instanceof Error ? error.message : 'Unknown error'}`
-        });
-      }
-    });
-  }
-
-  /**
-   * Generates the Web Worker code
-   */
-  private generateWorkerCode(): string {
-    return `
-      self.addEventListener('message', function(event) {
-        const task = event.data;
-        
-        if (task.type === 'regex-test') {
-          const { pattern, text, timeout } = task.data;
-          const startTime = performance.now();
-          
-          try {
-            const regex = new RegExp(pattern, 'g');
-            const matches = [];
-            let match;
-            
-            while ((match = regex.exec(text)) !== null) {
-              matches.push([...match]);
-              
-              // Prevention of infinite loops
-              if (matches.length > 1000) {
-                throw new Error('Too many matches - possible infinite loop');
-              }
-            }
-            
-            const groups = {};
-            if (matches.length > 0) {
-              const firstMatch = matches[0];
-              for (let i = 1; i < firstMatch.length; i++) {
-                groups[\`group\${i}\`] = firstMatch[i];
-              }
-            }
-            
-            self.postMessage({
-              id: task.id,
-              type: 'regex-result',
-              data: {
-                match: matches.length > 0,
-                matches,
-                groups,
-                executionTime: performance.now() - startTime,
-                timeout: false
-              }
-            });
-          } catch (error) {
-            self.postMessage({
-              id: task.id,
-              type: 'regex-result',
-              data: {
-                match: false,
-                executionTime: performance.now() - startTime,
-                timeout: false,
-                error: error.message || 'Execution error'
-              }
-            });
-          }
-        }
-      });
-    `;
-  }
-
-  /**
-   * Calculates the complexity of a pattern
-   */
-  private calculateComplexity(pattern: string): number {
-    let complexity = 0;
-    
-    // Nested quantifiers increase complexity
-    complexity += (pattern.match(/\*\*/g) || []).length * 5;
-    complexity += (pattern.match(/\+\+/g) || []).length * 5;
-    complexity += (pattern.match(/\?\?/g) || []).length * 3;
-    
-    // Lookaheads/lookbehinds
-    complexity += (pattern.match(/\(\?\=/g) || []).length * 2;
-    complexity += (pattern.match(/\(\?\!/g) || []).length * 2;
-    complexity += (pattern.match(/\(\?\</g) || []).length * 3;
-    
-    // Nested groups
-    const openParens = (pattern.match(/\(/g) || []).length;
-    complexity += openParens * 0.5;
-    
-    // Pattern length
-    complexity += pattern.length * 0.01;
-    
-    return Math.round(complexity * 100) / 100;
-  }
-
-  /**
-   * Gets numeric risk level
-   */
-  private getRiskLevel(risk: 'low' | 'medium' | 'high' | 'critical'): number {
-    const levels = { 'low': 1, 'medium': 2, 'high': 3, 'critical': 4 };
-    return levels[risk] || 0;
-  }
-
-  /**
-   * Merges configuration with default values
-   */
-  private mergeConfig(config: RegexSecurityConfig): Required<RegexSecurityConfig> {
-    return {
-      timeout: config.timeout || 5000,
-      maxComplexity: config.maxComplexity || 10,
-      allowBacktracking: config.allowBacktracking || false,
-      safeMode: config.safeMode || false
-    };
-  }
-
-  /**
-   * Cleans up resources when the service is destroyed
-   */
-  ngOnDestroy(): void {
-    this.workers.forEach(worker => {
-      worker.terminate();
-    });
-    this.workers.clear();
-  }
-}
-
-/**
- * Builder pattern to construct safe regular expressions
- */
-export class RegexSecurityBuilder {
-  private patternValue: string = '';
-  private optionsValue: RegexBuilderOptions = {};
-  private securityConfigValue: RegexSecurityConfig = {};
-
-  /**
-   * Defines the base pattern
-   */
-  pattern(pattern: string): RegexSecurityBuilder {
-    this.patternValue = pattern;
-    return this;
-  }
-
-  /**
-   * Appends text to the current pattern
-   */
-  append(text: string): RegexSecurityBuilder {
-    this.patternValue += text;
-    return this;
-  }
-
-  /**
-   * Adds a capturing group
-   */
-  group(content: string, name?: string): RegexSecurityBuilder {
-    if (name) {
-      this.patternValue += `(?<${name}>${content})`;
-    } else {
-      this.patternValue += `(${content})`;
-    }
-    return this;
-  }
-
-  /**
-   * Adds a non-capturing group
-   */
-  nonCapturingGroup(content: string): RegexSecurityBuilder {
-    this.patternValue += `(?:${content})`;
-    return this;
-  }
-
-  /**
-   * Adds an alternative
-   */
-  or(alternative: string): RegexSecurityBuilder {
-    this.patternValue += `|${alternative}`;
-    return this;
-  }
-
-  /**
-   * Adds a quantifier
-   */
-  quantifier(quantifier: '*' | '+' | '?' | '{n}' | '{n,}' | '{n,m}'): RegexSecurityBuilder {
-    this.patternValue += quantifier;
-    return this;
-  }
-
-  /**
-   * Adds a character set
-   */
-  characterSet(chars: string, negate = false): RegexSecurityBuilder {
-    this.patternValue += `[${negate ? '^' : ''}${chars}]`;
-    return this;
-  }
-
-  /**
-   * Adds a start of line anchor
-   */
-  startOfLine(): RegexSecurityBuilder {
-    this.patternValue += '^';
-    return this;
-  }
-
-  /**
-   * Adds an end of line anchor
-   */
-  endOfLine(): RegexSecurityBuilder {
-    this.patternValue += '$';
-    return this;
-  }
-
-  /**
-   * Configures regular expression options
-   */
-  options(options: RegexBuilderOptions): RegexSecurityBuilder {
-    this.optionsValue = { ...this.optionsValue, ...options };
-    return this;
-  }
-
-  /**
-   * Configures security options
-   */
-  security(config: RegexSecurityConfig): RegexSecurityBuilder {
-    this.securityConfigValue = { ...this.securityConfigValue, ...config };
-    return this;
-  }
-
-  /**
-   * Configures timeout
-   */
-  timeout(ms: number): RegexSecurityBuilder {
-    this.securityConfigValue.timeout = ms;
-    return this;
-  }
-
-  /**
-   * Activates safe mode
-   */
-  safeMode(): RegexSecurityBuilder {
-    this.securityConfigValue.safeMode = true;
-    return this;
-  }
-
-  /**
-   * Builds the final regular expression
-   */
-  build(): { pattern: string; options: RegexBuilderOptions; security: RegexSecurityConfig } {
-    return {
-      pattern: this.patternValue,
-      options: this.optionsValue,
-      security: this.securityConfigValue
-    };
-  }
-
-  /**
-   * Builds and executes the regular expression
-   */
-  async execute(text: string, service: RegexSecurityService): Promise<RegexTestResult> {
-    const { pattern, security } = this.build();
-    return service.testRegex(pattern, text, security);
-  }
-}