@arclabs561/ai-visual-test 0.5.1

package/src/validators/accessibility-programmatic.mjs

@@ -0,0 +1,345 @@
+/**
+ * Programmatic Accessibility Validator
+ * 
+ * Fast, deterministic accessibility checks using DOM inspection.
+ * Use this when you have Playwright page access and need fast feedback (<100ms).
+ * 
+ * For semantic evaluation (design principles, context-aware checks), use AccessibilityValidator (VLLM-based).
+ * 
+ * Based on WCAG 2.1 contrast ratio algorithm: https://www.w3.org/WAI/WCAG21/Understanding/contrast-minimum.html
+ */
+
+import { ValidationError } from '../errors.mjs';
+import { assertString, assertNumber } from '../type-guards.mjs';
+
+/**
+ * Parse RGB color string to [r, g, b] array
+ * Supports rgb(r, g, b), rgba(r, g, b, a), and hex (#rrggbb or #rgb) formats
+ * 
+ * @param {string} rgb - Color string
+ * @returns {number[]} [r, g, b] array (0-255)
+ */
+function parseRgb(rgb) {
+  if (!rgb || typeof rgb !== 'string') {
+    return [255, 255, 255]; // Default to white
+  }
+  
+  // Handle rgb(r, g, b) or rgba(r, g, b, a) format
+  const match = rgb.match(/\d+/g);
+  if (match && match.length >= 3) {
+    return match.slice(0, 3).map(Number);
+  }
+  
+  // Handle hex format (#rrggbb or #rgb)
+  if (rgb.startsWith('#')) {
+    const hex = rgb.slice(1);
+    if (hex.length === 3) {
+      return hex.split('').map(c => parseInt(c + c, 16));
+    }
+    if (hex.length === 6) {
+      return [
+        parseInt(hex.slice(0, 2), 16),
+        parseInt(hex.slice(2, 4), 16),
+        parseInt(hex.slice(4, 6), 16)
+      ];
+    }
+  }
+  
+  return [255, 255, 255]; // Default to white
+}
+
+/**
+ * Calculate relative luminance (WCAG algorithm)
+ * 
+ * @param {number[]} rgb - [r, g, b] array (0-255)
+ * @returns {number} Relative luminance (0-1)
+ */
+function getLuminance(rgb) {
+  const [r, g, b] = rgb.map(val => {
+    val = val / 255;
+    return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+/**
+ * Calculate contrast ratio between two colors (WCAG algorithm)
+ * 
+ * @param {string} color1 - First color (rgb, rgba, or hex)
+ * @param {string} color2 - Second color (rgb, rgba, or hex)
+ * @returns {number} Contrast ratio (1.0 to 21.0+)
+ */
+export function getContrastRatio(color1, color2) {
+  const rgb1 = parseRgb(color1);
+  const rgb2 = parseRgb(color2);
+  
+  const l1 = getLuminance(rgb1);
+  const l2 = getLuminance(rgb2);
+  
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+/**
+ * Check contrast ratio for an element
+ * 
+ * @param {any} page - Playwright page object
+ * @param {string} selector - CSS selector for element
+ * @param {number} minRatio - Minimum required contrast ratio (default: 4.5 for WCAG-AA)
+ * @returns {Promise<{ratio: number, passes: boolean, foreground: string, background: string, foregroundRgb?: number[], backgroundRgb?: number[], error?: string}>}
+ * @throws {ValidationError} If page is not a valid Playwright Page object
+ */
+export async function checkElementContrast(page, selector, minRatio = 4.5) {
+  // Validate inputs
+  if (!page || typeof page.evaluate !== 'function') {
+    throw new ValidationError('checkElementContrast requires a Playwright Page object', {
+      received: typeof page,
+      hasEvaluate: typeof page?.evaluate === 'function'
+    });
+  }
+  
+  assertString(selector, 'selector');
+  assertNumber(minRatio, 'minRatio');
+  
+  if (minRatio < 1 || minRatio > 21) {
+    throw new ValidationError('minRatio must be between 1 and 21', { received: minRatio });
+  }
+  
+  const result = await page.evaluate(({ sel, min }) => {
+    const element = document.querySelector(sel);
+    if (!element) {
+      return { error: 'Element not found', selector: sel };
+    }
+    
+    const style = window.getComputedStyle(element);
+    const color = style.color;
+    const bgColor = style.backgroundColor;
+    
+    // Get effective background color from parent if element has transparent background
+    let effectiveBg = bgColor;
+    if (bgColor === 'rgba(0, 0, 0, 0)' || bgColor === 'transparent') {
+      let parent = element.parentElement;
+      while (parent && parent !== document.body) {
+        const parentStyle = window.getComputedStyle(parent);
+        const parentBg = parentStyle.backgroundColor;
+        if (parentBg !== 'rgba(0, 0, 0, 0)' && parentBg !== 'transparent') {
+          effectiveBg = parentBg;
+          break;
+        }
+        parent = parent.parentElement;
+      }
+      
+      // If still transparent, check document.body
+      if ((effectiveBg === 'rgba(0, 0, 0, 0)' || effectiveBg === 'transparent') && document.body) {
+        const bodyStyle = window.getComputedStyle(document.body);
+        const bodyBg = bodyStyle.backgroundColor;
+        if (bodyBg !== 'rgba(0, 0, 0, 0)' && bodyBg !== 'transparent') {
+          effectiveBg = bodyBg;
+        }
+      }
+    }
+    
+    // Parse RGB values
+    const parseRgb = (rgb) => {
+      if (!rgb || typeof rgb !== 'string') return [255, 255, 255];
+      const match = rgb.match(/\d+/g);
+      return match && match.length >= 3 ? match.slice(0, 3).map(Number) : [255, 255, 255];
+    };
+    
+    const fg = parseRgb(color);
+    const bg = parseRgb(effectiveBg);
+    
+    // Calculate relative luminance (WCAG algorithm)
+    const getLuminance = (rgb) => {
+      const [r, g, b] = rgb.map(val => {
+        val = val / 255;
+        return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
+      });
+      return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    };
+    
+    const l1 = getLuminance(fg);
+    const l2 = getLuminance(bg);
+    const ratio = (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+    
+    return {
+      ratio,
+      passes: ratio >= min,
+      foreground: color,
+      background: effectiveBg,
+      foregroundRgb: fg,
+      backgroundRgb: bg
+    };
+  }, { sel: selector, min: minRatio });
+  
+  return result;
+}
+
+/**
+ * Check contrast for all text elements on page
+ * 
+ * @param {any} page - Playwright page object
+ * @param {number} minRatio - Minimum required contrast ratio (default: 4.5 for WCAG-AA)
+ * @returns {Promise<{total: number, passing: number, failing: number, violations: Array<{element: string, ratio: string, required: number, foreground: string, background: string}>, elements?: Array}>}
+ * @throws {ValidationError} If page is not a valid Playwright Page object
+ */
+export async function checkAllTextContrast(page, minRatio = 4.5) {
+  // Validate inputs
+  if (!page || typeof page.evaluate !== 'function') {
+    throw new ValidationError('checkAllTextContrast requires a Playwright Page object', {
+      received: typeof page,
+      hasEvaluate: typeof page?.evaluate === 'function'
+    });
+  }
+  
+  assertNumber(minRatio, 'minRatio');
+  
+  if (minRatio < 1 || minRatio > 21) {
+    throw new ValidationError('minRatio must be between 1 and 21', { received: minRatio });
+  }
+  
+  const result = await page.evaluate((min) => {
+    const all = document.querySelectorAll('*');
+    const textElements = [];
+    const violations = [];
+    
+    const parseRgb = (rgb) => {
+      if (!rgb || typeof rgb !== 'string') return [255, 255, 255];
+      const match = rgb.match(/\d+/g);
+      return match && match.length >= 3 ? match.slice(0, 3).map(Number) : [255, 255, 255];
+    };
+    
+    const getLuminance = (rgb) => {
+      const [r, g, b] = rgb.map(val => {
+        val = val / 255;
+        return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
+      });
+      return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    };
+    
+    for (const el of all) {
+      const style = window.getComputedStyle(el);
+      const color = style.color;
+      const bgColor = style.backgroundColor;
+      
+      // Check if element has text content
+      if (el.textContent && el.textContent.trim().length > 0 && 
+          color && color !== 'rgba(0, 0, 0, 0)' && 
+          bgColor && bgColor !== 'rgba(0, 0, 0, 0)') {
+        
+        // Get effective background (handle transparent)
+        let effectiveBg = bgColor;
+        if (bgColor === 'rgba(0, 0, 0, 0)' || bgColor === 'transparent') {
+          let parent = el.parentElement;
+          while (parent && parent !== document.body) {
+            const parentStyle = window.getComputedStyle(parent);
+            const parentBg = parentStyle.backgroundColor;
+            if (parentBg !== 'rgba(0, 0, 0, 0)' && parentBg !== 'transparent') {
+              effectiveBg = parentBg;
+              break;
+            }
+            parent = parent.parentElement;
+          }
+          
+          // If still transparent, check document.body
+          if ((effectiveBg === 'rgba(0, 0, 0, 0)' || effectiveBg === 'transparent') && document.body) {
+            const bodyStyle = window.getComputedStyle(document.body);
+            const bodyBg = bodyStyle.backgroundColor;
+            if (bodyBg !== 'rgba(0, 0, 0, 0)' && bodyBg !== 'transparent') {
+              effectiveBg = bodyBg;
+            }
+          }
+        }
+        
+        const fg = parseRgb(color);
+        const bg = parseRgb(effectiveBg);
+        
+        const l1 = getLuminance(fg);
+        const l2 = getLuminance(bg);
+        const ratio = (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+        
+        const elementInfo = {
+          tag: el.tagName,
+          id: el.id,
+          className: el.className,
+          ratio,
+          passes: ratio >= min,
+          foreground: color,
+          background: effectiveBg
+        };
+        
+        textElements.push(elementInfo);
+        
+        if (!elementInfo.passes) {
+          violations.push({
+            element: `${el.tagName}${el.id ? '#' + el.id : ''}${el.className ? '.' + el.className.split(' ')[0] : ''}`,
+            ratio: ratio.toFixed(2),
+            required: min,
+            foreground: color,
+            background: effectiveBg
+          });
+        }
+      }
+    }
+    
+    return {
+      total: textElements.length,
+      passing: textElements.filter(e => e.passes).length,
+      failing: textElements.filter(e => !e.passes).length,
+      violations: violations,
+      elements: textElements.slice(0, 20) // First 20 for debugging
+    };
+  }, minRatio);
+  
+  return result;
+}
+
+/**
+ * Check keyboard navigation accessibility
+ * 
+ * @param {any} page - Playwright page object
+ * @returns {Promise<{keyboardAccessible: boolean, focusableElements: number, violations: Array<{element: string, issue: string}>, focusableSelectors: string[]}>}
+ * @throws {ValidationError} If page is not a valid Playwright Page object
+ */
+export async function checkKeyboardNavigation(page) {
+  // Validate inputs
+  if (!page || typeof page.evaluate !== 'function') {
+    throw new ValidationError('checkKeyboardNavigation requires a Playwright Page object', {
+      received: typeof page,
+      hasEvaluate: typeof page?.evaluate === 'function'
+    });
+  }
+  
+  const result = await page.evaluate(() => {
+    const focusableSelectors = [
+      'a[href]',
+      'button:not([disabled])',
+      'input:not([disabled])',
+      'select:not([disabled])',
+      'textarea:not([disabled])',
+      '[tabindex]:not([tabindex="-1"])'
+    ];
+    
+    const focusableElements = Array.from(document.querySelectorAll(focusableSelectors.join(', ')));
+    const violations = [];
+    
+    // Check for missing focus indicators
+    focusableElements.forEach(el => {
+      const style = window.getComputedStyle(el, ':focus');
+      // Note: :focus pseudo-class can't be checked directly in evaluate
+      // This is a basic check - full focus indicator check would require interaction
+    });
+    
+    return {
+      keyboardAccessible: focusableElements.length > 0,
+      focusableElements: focusableElements.length,
+      violations: violations,
+      focusableSelectors: focusableSelectors
+    };
+  });
+  
+  return result;
+}
+

package/src/validators/accessibility-validator.mjs

@@ -0,0 +1,223 @@
+/**
+ * Accessibility Validator
+ * 
+ * Configurable accessibility validation with WCAG standards support
+ * 
+ * Provides:
+ * - Configurable contrast requirements (WCAG-AA, WCAG-AAA, custom)
+ * - Zero tolerance enforcement
+ * - Violation detection and reporting
+ * - Extensible via plugins
+ */
+
+import { validateScreenshot } from '../judge.mjs';
+import { ValidationError } from '../errors.mjs';
+import { assertString } from '../type-guards.mjs';
+
+/**
+ * Accessibility validator with configurable standards
+ */
+export class AccessibilityValidator {
+  constructor(options = {}) {
+    // Validate minContrast
+    if (options.minContrast !== undefined) {
+      if (typeof options.minContrast !== 'number' || options.minContrast < 1 || isNaN(options.minContrast)) {
+        throw new ValidationError(
+          'minContrast must be a number >= 1',
+          { received: options.minContrast }
+        );
+      }
+      this.minContrast = options.minContrast;
+    } else {
+      this.minContrast = 4.5; // WCAG AA default, configurable
+    }
+    
+    // Validate standards
+    if (options.standards !== undefined) {
+      if (!Array.isArray(options.standards)) {
+        throw new ValidationError(
+          'standards must be an array',
+          { received: typeof options.standards }
+        );
+      }
+      this.standards = options.standards;
+    } else {
+      this.standards = ['WCAG-AA']; // Can be WCAG-AA, WCAG-AAA, custom
+    }
+    
+    this.zeroTolerance = options.zeroTolerance || false; // Whether violations cause instant fail
+    this.validateScreenshot = options.validateScreenshot || validateScreenshot;
+  }
+
+  /**
+   * Static method for quick validation without instantiation
+   * 
+   * @param {string} screenshotPath - Path to screenshot
+   * @param {object} options - Validation options (minContrast, standards, etc.)
+   * @returns {Promise<object>} Validation result with violations and contrast info
+   */
+  static async validate(screenshotPath, options = {}) {
+    const validator = new AccessibilityValidator(options);
+    return validator.validateAccessibility(screenshotPath, options);
+  }
+
+  /**
+   * Validate accessibility with configurable standards
+   * 
+   * @param {string | string[]} screenshotPath - Path to screenshot(s) - supports multi-image for comparison
+   * @param {object} options - Validation options
+   */
+  async validateAccessibility(screenshotPath, options = {}) {
+    // Input validation - support both single and array
+    const isArray = Array.isArray(screenshotPath);
+    if (!isArray) {
+      assertString(screenshotPath, 'screenshotPath');
+    } else {
+      screenshotPath.forEach((path, i) => {
+        assertString(path, `screenshotPath[${i}]`);
+      });
+    }
+    
+    if (options.minContrast !== undefined && (typeof options.minContrast !== 'number' || options.minContrast < 1)) {
+      throw new ValidationError(
+        'minContrast must be a number >= 1',
+        { received: options.minContrast }
+      );
+    }
+    
+    // Allow custom prompt override
+    const prompt = options.customPrompt || this.buildAccessibilityPrompt(options);
+    
+    try {
+      // Pass through all validateScreenshot options
+      const screenshotOptions = {
+        testType: options.testType || 'accessibility',
+        minContrast: this.minContrast,
+        standards: this.standards,
+        ...options,
+        // Explicitly pass through common options
+        useCache: options.useCache !== undefined ? options.useCache : undefined,
+        timeout: options.timeout,
+        provider: options.provider,
+        viewport: options.viewport
+      };
+      
+      const result = await this.validateScreenshot(screenshotPath, prompt, screenshotOptions);
+
+      // Check for violations
+      const violations = this.detectViolations(result);
+      
+      // Auto-fail if zero tolerance enabled
+      const passes = this.zeroTolerance 
+        ? violations.zeroTolerance.length === 0 && violations.critical.length === 0
+        : true; // Don't auto-fail if zero tolerance disabled
+      
+      return {
+        ...result,
+        violations,
+        passes,
+        contrastCheck: this.extractContrastInfo(result),
+        standards: this.standards
+      };
+    } catch (error) {
+      // Re-throw ValidationError as-is, wrap others
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      throw new ValidationError(
+        `Accessibility validation failed: ${error.message}`,
+        { screenshotPath, standards: this.standards, originalError: error.message }
+      );
+    }
+  }
+
+  /**
+   * Build accessibility validation prompt
+   */
+  buildAccessibilityPrompt(options = {}) {
+    const failText = this.zeroTolerance 
+      ? `ZERO TOLERANCE (AUTOMATIC FAIL):
+- Contrast <${this.minContrast}:1 for ANY critical text = INSTANT FAIL
+- Contrast <${this.minContrast}:1 for interactive elements = INSTANT FAIL
+- No keyboard navigation = INSTANT FAIL
+- No screen reader support = INSTANT FAIL`
+      : `REQUIREMENTS:
+- Contrast should be ≥${this.minContrast}:1 for all text
+- All interactive elements should be keyboard accessible
+- Screen reader compatibility required`;
+
+    return `Accessibility validation (${this.standards.join(', ')}):
+
+${failText}
+
+STANDARDS:
+${this.standards.map(s => `- ${s}`).join('\n')}
+
+REQUIREMENTS:
+1. All text must have ≥${this.minContrast}:1 contrast ratio
+2. All interactive elements must be keyboard accessible
+3. All images must have alt text
+4. Semantic HTML structure required
+5. Focus indicators must be visible
+
+Return detailed assessment with:
+- Contrast ratios for all text elements
+- Keyboard navigation status
+- Screen reader compatibility
+- WCAG compliance level
+- List of violations`;
+  }
+
+  /**
+   * Detect accessibility violations
+   */
+  detectViolations(result) {
+    const zeroTolerance = [];
+    const critical = [];
+    const warnings = [];
+    
+    const text = (result.reasoning || result.assessment || '').toLowerCase();
+    
+    // Check for contrast violations
+    if (text.includes(`contrast <${this.minContrast}`) || text.includes('contrast too low')) {
+      (this.zeroTolerance ? zeroTolerance : critical).push('Contrast below minimum requirement');
+    }
+    
+    // Check for keyboard navigation
+    if (text.includes('no keyboard') || text.includes('keyboard inaccessible')) {
+      (this.zeroTolerance ? zeroTolerance : critical).push('Keyboard navigation missing');
+    }
+    
+    // Check for screen reader
+    if (text.includes('no screen reader') || text.includes('screen reader incompatible')) {
+      (this.zeroTolerance ? zeroTolerance : critical).push('Screen reader support missing');
+    }
+    
+    return { zeroTolerance, critical, warnings };
+  }
+
+  /**
+   * Extract contrast information from result
+   */
+  extractContrastInfo(result) {
+    const text = result.reasoning || result.assessment || '';
+    const contrastMatches = text.match(/(\d+(?:\.\d+)?):1/g);
+    
+    if (!contrastMatches || contrastMatches.length === 0) {
+      return {
+        ratios: [],
+        minRatio: null,
+        meetsRequirement: null
+      };
+    }
+    
+    const ratios = contrastMatches.map(m => parseFloat(m)).filter(n => !isNaN(n) && isFinite(n));
+    
+    return {
+      ratios: contrastMatches,
+      minRatio: ratios.length > 0 ? Math.min(...ratios) : null,
+      meetsRequirement: ratios.length > 0 ? ratios.every(r => r >= this.minContrast) : null
+    };
+  }
+}
+

package/src/validators/batch-validator.mjs

@@ -0,0 +1,143 @@
+/**
+ * Batch Validator
+ * 
+ * Enhanced BatchOptimizer with cost tracking and statistics
+ * 
+ * Provides:
+ * - All BatchOptimizer functionality
+ * - Cost tracking integration
+ * - Performance statistics
+ * - Success rate tracking
+ */
+
+import { BatchOptimizer } from '../batch-optimizer.mjs';
+import { getCostTracker } from '../cost-tracker.mjs';
+
+/**
+ * Batch validator with cost tracking
+ */
+export class BatchValidator extends BatchOptimizer {
+  constructor(options = {}) {
+    super({
+      maxConcurrency: options.maxConcurrency || 5,
+      batchSize: options.batchSize || 3,
+      cacheEnabled: options.cacheEnabled !== false,
+      ...options
+    });
+    this.costTracker = getCostTracker();
+    this.trackCosts = options.trackCosts !== false;
+    this.trackStats = options.trackStats !== false;
+    this.stats = {
+      totalRequests: 0,
+      totalDuration: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      minDuration: Infinity,
+      maxDuration: 0
+    };
+  }
+
+  /**
+   * Validate multiple screenshots with cost tracking
+   */
+  async batchValidate(screenshots, prompt, context = {}) {
+    const startTime = Date.now();
+    
+    const results = await super.batchValidate(screenshots, prompt, context);
+    
+    const duration = Date.now() - startTime;
+    
+    // Track costs
+    if (this.trackCosts && this.costTracker) {
+      const screenshotsArray = Array.isArray(screenshots) ? screenshots : [screenshots];
+      results.forEach((result, index) => {
+        if (result.estimatedCost) {
+          try {
+            this.costTracker.recordCost({
+              provider: result.provider,
+              cost: result.estimatedCost.total || 0,
+              tokens: result.estimatedCost.tokens || 0,
+              testType: context.testType || 'batch',
+              screenshot: screenshotsArray[index]
+            });
+          } catch (error) {
+            // Silently fail cost tracking to avoid breaking validation
+            // Could log warning in production
+          }
+        }
+      });
+    }
+    
+    // Track stats
+    if (this.trackStats) {
+      this.stats.totalRequests += results.length;
+      this.stats.totalDuration += duration;
+      this.stats.minDuration = Math.min(this.stats.minDuration, duration);
+      this.stats.maxDuration = Math.max(this.stats.maxDuration, duration);
+      
+      results.forEach(result => {
+        if (result.error) {
+          this.stats.failedRequests++;
+        } else {
+          this.stats.successfulRequests++;
+        }
+      });
+    }
+    
+    return {
+      results,
+      stats: this.trackStats ? {
+        total: screenshots.length,
+        passed: results.filter(r => (r.score || 0) >= (context.passingScore || 7)).length,
+        failed: results.filter(r => (r.score || 0) < (context.passingScore || 7)).length,
+        duration,
+        costStats: this.trackCosts && this.costTracker ? this.costTracker.getStats() : null,
+        performance: this.trackStats ? {
+          totalRequests: this.stats.totalRequests,
+          avgDuration: this.stats.totalRequests > 0 ? this.stats.totalDuration / this.stats.totalRequests : 0,
+          minDuration: this.stats.minDuration === Infinity ? 0 : this.stats.minDuration,
+          maxDuration: this.stats.maxDuration,
+          successRate: this.stats.totalRequests > 0 ? this.stats.successfulRequests / this.stats.totalRequests : 0
+        } : null
+      } : null
+    };
+  }
+
+  /**
+   * Get cost statistics
+   */
+  getCostStats() {
+    if (!this.costTracker) {
+      return null;
+    }
+    return this.costTracker.getStats();
+  }
+
+  /**
+   * Get performance statistics
+   */
+  getPerformanceStats() {
+    return {
+      totalRequests: this.stats.totalRequests,
+      avgDuration: this.stats.totalRequests > 0 ? this.stats.totalDuration / this.stats.totalRequests : 0,
+      minDuration: this.stats.minDuration === Infinity ? 0 : this.stats.minDuration,
+      maxDuration: this.stats.maxDuration,
+      successRate: this.stats.totalRequests > 0 ? this.stats.successfulRequests / this.stats.totalRequests : 0
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalRequests: 0,
+      totalDuration: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      minDuration: Infinity,
+      maxDuration: 0
+    };
+  }
+}
+