chrometools-mcp 1.9.1 → 2.3.2

package/utils/code-generators/playwright-typescript.js

@@ -227,4 +227,99 @@ export class PlaywrightTypeScriptGenerator extends CodeGeneratorBase {
       return [this.indent(`await expect(page).toHaveURL('${this.escapeString(expectedUrl)}');`)];
     }
   }
+
+  /**
+   * Append test to existing TypeScript file
+   */
+  appendTest(existingContent, newTestCode, options = {}) {
+    const lines = existingContent.split('\n');
+    const insertPosition = options.insertPosition || 'end';
+    const referenceTestName = options.referenceTestName;
+
+    let insertIndex;
+
+    if (insertPosition === 'end') {
+      // Insert at end of file (or before last closing brace if exists)
+      insertIndex = this.findLastTestEnd(lines);
+    } else if (insertPosition === 'before' || insertPosition === 'after') {
+      if (!referenceTestName) {
+        throw new Error(`referenceTestName is required for insertPosition '${insertPosition}'`);
+      }
+
+      insertIndex = this.findTestByName(lines, referenceTestName);
+      if (insertIndex === -1) {
+        throw new Error(`Reference test '${referenceTestName}' not found in file`);
+      }
+
+      if (insertPosition === 'after') {
+        insertIndex = this.findTestEnd(lines, insertIndex);
+      }
+    }
+
+    // Insert new test with proper spacing
+    lines.splice(insertIndex, 0, '', newTestCode, '');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Find test function by name
+   */
+  findTestByName(lines, testName) {
+    const testRegex = new RegExp(`test\\(['"\`]${testName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"\`]`);
+    return lines.findIndex(line => testRegex.test(line));
+  }
+
+  /**
+   * Find end of test function
+   */
+  findTestEnd(lines, startIndex) {
+    let braceCount = 0;
+    let started = false;
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Count braces
+      for (const char of line) {
+        if (char === '{') {
+          braceCount++;
+          started = true;
+        } else if (char === '}') {
+          braceCount--;
+        }
+      }
+
+      // When braces balance out after starting, we found the end
+      if (started && braceCount === 0) {
+        return i + 1;
+      }
+    }
+
+    return lines.length;
+  }
+
+  /**
+   * Find last test end (for 'end' insertion)
+   */
+  findLastTestEnd(lines) {
+    // Find last test() call
+    let lastTestIndex = -1;
+    const testRegex = /test\(['"`]/;
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (testRegex.test(lines[i])) {
+        lastTestIndex = i;
+        break;
+      }
+    }
+
+    if (lastTestIndex === -1) {
+      // No tests found, insert at end
+      return lines.length;
+    }
+
+    // Find end of last test
+    return this.findTestEnd(lines, lastTestIndex);
+  }
 }

package/utils/code-generators/selenium-java.js

@@ -306,4 +306,127 @@ export class SeleniumJavaGenerator extends CodeGeneratorBase {
 
     return lines;
   }
+
+  /**
+   * Append test to existing Java file
+   */
+  appendTest(existingContent, newTestCode, options = {}) {
+    const lines = existingContent.split('\n');
+    const insertPosition = options.insertPosition || 'end';
+    const referenceTestName = options.referenceTestName;
+
+    let insertIndex;
+
+    if (insertPosition === 'end') {
+      // Insert before closing class brace
+      insertIndex = this.findLastJavaMethodEnd(lines);
+    } else if (insertPosition === 'before' || insertPosition === 'after') {
+      if (!referenceTestName) {
+        throw new Error(`referenceTestName is required for insertPosition '${insertPosition}'`);
+      }
+
+      const javaTestName = this.javaTestName(referenceTestName);
+      insertIndex = this.findJavaTestByName(lines, javaTestName);
+
+      if (insertIndex === -1) {
+        throw new Error(`Reference test '${referenceTestName}' not found in file`);
+      }
+
+      if (insertPosition === 'after') {
+        insertIndex = this.findJavaMethodEnd(lines, insertIndex);
+      }
+    }
+
+    // Insert new test with proper spacing
+    lines.splice(insertIndex, 0, '', this.indentBlock(newTestCode, 1), '');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Convert test name to Java camelCase convention
+   */
+  javaTestName(name) {
+    return name
+      .replace(/[_-](.)/g, (_, char) => char.toUpperCase())
+      .replace(/[_-]/g, '')
+      .replace(/ (.)/g, (_, char) => char.toUpperCase())
+      .replace(/ /g, '')
+      .replace(/^./, char => char.toLowerCase());
+  }
+
+  /**
+   * Find Java test method by name
+   */
+  findJavaTestByName(lines, testName) {
+    const testRegex = new RegExp(`public\\s+void\\s+${testName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\(`);
+    return lines.findIndex(line => testRegex.test(line.trim()));
+  }
+
+  /**
+   * Find end of Java method
+   */
+  findJavaMethodEnd(lines, startIndex) {
+    let braceCount = 0;
+    let started = false;
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+
+      for (const char of line) {
+        if (char === '{') {
+          braceCount++;
+          started = true;
+        } else if (char === '}') {
+          braceCount--;
+        }
+      }
+
+      if (started && braceCount === 0) {
+        return i + 1;
+      }
+    }
+
+    return lines.length;
+  }
+
+  /**
+   * Find last method end (for 'end' insertion - before closing class brace)
+   */
+  findLastJavaMethodEnd(lines) {
+    // Find last @Test annotation or public method
+    let lastMethodIndex = -1;
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const trimmed = lines[i].trim();
+      if (trimmed.startsWith('@Test') || trimmed.startsWith('public void test')) {
+        lastMethodIndex = i;
+        break;
+      }
+    }
+
+    if (lastMethodIndex === -1) {
+      // No methods found, insert before last closing brace
+      for (let i = lines.length - 1; i >= 0; i--) {
+        if (lines[i].trim() === '}') {
+          return i;
+        }
+      }
+      return lines.length;
+    }
+
+    // Find end of last method
+    return this.findJavaMethodEnd(lines, lastMethodIndex);
+  }
+
+  /**
+   * Indent entire code block by specified level
+   */
+  indentBlock(code, level = 1) {
+    const lines = code.split('\n');
+    return lines.map(line => {
+      if (line.trim() === '') return line;
+      return ' '.repeat(this.options.indentSize * level) + line;
+    }).join('\n');
+  }
 }

package/utils/code-generators/selenium-python.js

@@ -325,4 +325,86 @@ export class SeleniumPythonGenerator extends CodeGeneratorBase {
 
     return lines;
   }
+
+  /**
+   * Append test to existing Python file
+   * Reuses Python parsing logic similar to Playwright Python
+   */
+  appendTest(existingContent, newTestCode, options = {}) {
+    const lines = existingContent.split('\n');
+    const insertPosition = options.insertPosition || 'end';
+    const referenceTestName = options.referenceTestName;
+
+    let insertIndex;
+
+    if (insertPosition === 'end') {
+      // Insert at end of file
+      insertIndex = lines.length;
+    } else if (insertPosition === 'before' || insertPosition === 'after') {
+      if (!referenceTestName) {
+        throw new Error(`referenceTestName is required for insertPosition '${insertPosition}'`);
+      }
+
+      const pythonTestName = this.pythonTestName(referenceTestName);
+      insertIndex = this.findPythonTestByName(lines, pythonTestName);
+
+      if (insertIndex === -1) {
+        throw new Error(`Reference test '${referenceTestName}' not found in file`);
+      }
+
+      if (insertPosition === 'after') {
+        insertIndex = this.findPythonTestEnd(lines, insertIndex);
+      }
+    }
+
+    // Insert new test with proper spacing (2 blank lines before test - PEP 8)
+    lines.splice(insertIndex, 0, '', '', newTestCode);
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Convert test name to Python convention
+   */
+  pythonTestName(name) {
+    return name
+      .replace(/([A-Z])/g, '_$1')
+      .replace(/-/g, '_')
+      .replace(/ /g, '_')
+      .toLowerCase()
+      .replace(/^_/, '')
+      .replace(/__+/g, '_');
+  }
+
+  /**
+   * Find Python test function by name
+   */
+  findPythonTestByName(lines, testName) {
+    const testRegex = new RegExp(`^def test_${testName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\(`);
+    return lines.findIndex(line => testRegex.test(line.trim()));
+  }
+
+  /**
+   * Find end of Python function (next def/class or end of file)
+   */
+  findPythonTestEnd(lines, startIndex) {
+    const startLine = lines[startIndex];
+    const startIndent = startLine.match(/^\s*/)[0].length;
+
+    for (let i = startIndex + 1; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+
+      if (trimmed === '' || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      const currentIndent = lines[i].match(/^\s*/)[0].length;
+
+      if (currentIndent <= startIndent && (trimmed.startsWith('def ') || trimmed.startsWith('class '))) {
+        return i;
+      }
+    }
+
+    return lines.length;
+  }
 }

package/utils/css-utils.js

@@ -0,0 +1,151 @@
+/**
+ * utils/css-utils.js
+ *
+ * CSS utilities for filtering and categorizing CSS properties
+ */
+
+/**
+ * CSS property categorization
+ */
+export const CSS_CATEGORIES = {
+  layout: [
+    'width', 'height', 'min-width', 'min-height', 'max-width', 'max-height',
+    'margin', 'margin-top', 'margin-right', 'margin-bottom', 'margin-left',
+    'padding', 'padding-top', 'padding-right', 'padding-bottom', 'padding-left',
+    'position', 'top', 'right', 'bottom', 'left', 'z-index',
+    'display', 'float', 'clear', 'overflow', 'overflow-x', 'overflow-y',
+    'flex', 'flex-direction', 'flex-wrap', 'flex-grow', 'flex-shrink', 'flex-basis',
+    'justify-content', 'align-items', 'align-content', 'align-self', 'order',
+    'grid', 'grid-template', 'grid-template-columns', 'grid-template-rows', 'grid-gap',
+    'gap', 'row-gap', 'column-gap',
+    'box-sizing', 'visibility', 'clip', 'clip-path'
+  ],
+  typography: [
+    'font', 'font-family', 'font-size', 'font-weight', 'font-style', 'font-variant',
+    'line-height', 'letter-spacing', 'word-spacing', 'text-align', 'text-decoration',
+    'text-transform', 'text-indent', 'text-overflow', 'white-space', 'word-break',
+    'word-wrap', 'overflow-wrap', 'hyphens', 'direction', 'unicode-bidi',
+    'writing-mode', 'vertical-align'
+  ],
+  colors: [
+    'color', 'background', 'background-color', 'background-image', 'background-position',
+    'background-size', 'background-repeat', 'background-attachment', 'background-clip',
+    'background-origin', 'background-blend-mode',
+    'border-color', 'border-top-color', 'border-right-color', 'border-bottom-color', 'border-left-color',
+    'outline-color', 'text-decoration-color', 'caret-color', 'column-rule-color'
+  ],
+  visual: [
+    'opacity', 'transform', 'transform-origin', 'transform-style', 'perspective',
+    'perspective-origin', 'backface-visibility',
+    'transition', 'transition-property', 'transition-duration', 'transition-timing-function', 'transition-delay',
+    'animation', 'animation-name', 'animation-duration', 'animation-timing-function', 'animation-delay',
+    'animation-iteration-count', 'animation-direction', 'animation-fill-mode', 'animation-play-state',
+    'filter', 'backdrop-filter', 'mix-blend-mode', 'isolation',
+    'box-shadow', 'text-shadow',
+    'border', 'border-width', 'border-style', 'border-radius',
+    'border-top', 'border-right', 'border-bottom', 'border-left',
+    'border-top-width', 'border-right-width', 'border-bottom-width', 'border-left-width',
+    'border-top-style', 'border-right-style', 'border-bottom-style', 'border-left-style',
+    'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius',
+    'outline', 'outline-width', 'outline-style', 'outline-offset',
+    'cursor', 'pointer-events', 'user-select'
+  ]
+};
+
+/**
+ * Common default CSS values to filter out
+ */
+export const CSS_DEFAULTS = {
+  'display': 'inline',
+  'position': 'static',
+  'float': 'none',
+  'clear': 'none',
+  'visibility': 'visible',
+  'overflow': 'visible',
+  'overflow-x': 'visible',
+  'overflow-y': 'visible',
+  'z-index': 'auto',
+  'opacity': '1',
+  'transform': 'none',
+  'filter': 'none',
+  'backdrop-filter': 'none',
+  'box-shadow': 'none',
+  'text-shadow': 'none',
+  'border-style': 'none',
+  'border-width': '0px',
+  'outline-style': 'none',
+  'outline-width': '0px',
+  'margin': '0px',
+  'margin-top': '0px',
+  'margin-right': '0px',
+  'margin-bottom': '0px',
+  'margin-left': '0px',
+  'padding': '0px',
+  'padding-top': '0px',
+  'padding-right': '0px',
+  'padding-bottom': '0px',
+  'padding-left': '0px',
+  'background-image': 'none',
+  'transition': 'all 0s ease 0s',
+  'animation': 'none',
+  'pointer-events': 'auto',
+  'user-select': 'auto',
+  'cursor': 'auto',
+  'text-decoration': 'none',
+  'text-transform': 'none',
+  'font-weight': '400',
+  'font-style': 'normal',
+  'font-variant': 'normal',
+  'letter-spacing': 'normal',
+  'word-spacing': 'normal',
+  'text-align': 'start',
+  'white-space': 'normal',
+  'word-break': 'normal',
+  'overflow-wrap': 'normal',
+  'hyphens': 'manual'
+};
+
+/**
+ * Filter computed CSS styles based on options
+ * @param {Array} computedStyle - Array of CSS property objects with name and value
+ * @param {Object} options - Filter options
+ * @param {string} options.category - Category to filter by ('layout', 'typography', 'colors', 'visual', 'all')
+ * @param {string[]} options.properties - Specific properties to include
+ * @param {boolean} options.includeDefaults - Include properties with default values
+ * @returns {Array} - Filtered CSS properties
+ */
+export function filterCssStyles(computedStyle, options = {}) {
+  const { category, properties, includeDefaults = false } = options;
+
+  let filtered = computedStyle;
+
+  // Filter by specific properties (highest priority)
+  if (properties && properties.length > 0) {
+    filtered = filtered.filter(prop =>
+      properties.some(p => prop.name.toLowerCase() === p.toLowerCase())
+    );
+  }
+  // Filter by category
+  else if (category && category !== 'all') {
+    const categoryProps = CSS_CATEGORIES[category] || [];
+    filtered = filtered.filter(prop =>
+      categoryProps.some(p => prop.name.toLowerCase().startsWith(p.toLowerCase()))
+    );
+  }
+
+  // Filter out default values if requested
+  if (!includeDefaults) {
+    filtered = filtered.filter(prop => {
+      const defaultValue = CSS_DEFAULTS[prop.name];
+      if (!defaultValue) return true;
+
+      // Normalize values for comparison
+      const normalizedValue = prop.value.replace(/\s+/g, ' ').trim();
+      const normalizedDefault = defaultValue.replace(/\s+/g, ' ').trim();
+
+      return normalizedValue !== normalizedDefault;
+    });
+  }
+
+  return filtered;
+}

package/utils/image-processing.js

@@ -0,0 +1,236 @@
+/**
+ * utils/image-processing.js
+ *
+ * Image processing utilities for screenshots and comparisons
+ */
+
+import Jimp from 'jimp';
+
+/**
+ * Process screenshot with compression and scaling
+ * @param {Buffer} screenshotBuffer - Raw screenshot buffer
+ * @param {Object} options - Processing options
+ * @param {number} options.maxWidth - Maximum width (default: 1024)
+ * @param {number} options.maxHeight - Maximum height (default: 8000)
+ * @param {number} options.quality - JPEG quality (default: 80)
+ * @param {string} options.format - Output format: 'auto', 'png', 'jpeg' (default: 'auto')
+ * @param {number} options.maxFileSize - Maximum file size in bytes (default: 3MB)
+ * @returns {Promise<Object>} - Processed image data with metadata
+ */
+export async function processScreenshot(screenshotBuffer, options = {}) {
+  const {
+    maxWidth = 1024,
+    maxHeight = 8000, // API limit is 8000px
+    quality = 80,
+    format = 'auto',
+    maxFileSize = 3 * 1024 * 1024 // 3 MB limit
+  } = options;
+
+  // Load image with Jimp
+  const image = await Jimp.read(screenshotBuffer);
+  const originalWidth = image.bitmap.width;
+  const originalHeight = image.bitmap.height;
+  const originalSize = screenshotBuffer.length;
+
+  let processed = false;
+
+  // Apply scaling if needed to fit within maxWidth and maxHeight
+  if (maxWidth !== null || maxHeight !== null) {
+    let newWidth = originalWidth;
+    let newHeight = originalHeight;
+
+    // Calculate scale factors for both dimensions
+    let scaleWidth = 1.0;
+    let scaleHeight = 1.0;
+
+    if (maxWidth !== null && originalWidth > maxWidth) {
+      scaleWidth = maxWidth / originalWidth;
+    }
+
+    if (maxHeight !== null && originalHeight > maxHeight) {
+      scaleHeight = maxHeight / originalHeight;
+    }
+
+    // Use the smaller scale factor to ensure both dimensions fit
+    const scale = Math.min(scaleWidth, scaleHeight);
+
+    if (scale < 1.0) {
+      newWidth = Math.round(originalWidth * scale);
+      newHeight = Math.round(originalHeight * scale);
+      image.resize(newWidth, newHeight);
+      processed = true;
+    }
+  }
+
+  // Determine output format
+  let outputFormat = format;
+  let mimeType = 'image/png';
+
+  if (format === 'auto') {
+    // Auto-select: use JPEG for large images, PNG for small
+    const estimatedSize = image.bitmap.width * image.bitmap.height * 4;
+    outputFormat = estimatedSize > 500000 ? 'jpeg' : 'png'; // ~500KB threshold
+  }
+
+  // Convert to buffer with appropriate format and quality
+  let currentQuality = quality;
+  let resultBuffer;
+  let compressionAttempts = 0;
+  const maxCompressionAttempts = 10;
+
+  if (outputFormat === 'jpeg') {
+    image.quality(currentQuality);
+    resultBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
+    mimeType = 'image/jpeg';
+    processed = true;
+
+    // If file exceeds maxFileSize, reduce quality iteratively
+    while (resultBuffer.length > maxFileSize && compressionAttempts < maxCompressionAttempts) {
+      compressionAttempts++;
+      // Reduce quality by 10 points each iteration
+      currentQuality = Math.max(10, currentQuality - 10);
+      image.quality(currentQuality);
+      resultBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
+
+      // If quality is already at minimum and still too large, scale down the image
+      if (currentQuality === 10 && resultBuffer.length > maxFileSize) {
+        const scaleFactor = Math.sqrt(maxFileSize / resultBuffer.length * 0.9); // 0.9 for safety margin
+        const newWidth = Math.round(image.bitmap.width * scaleFactor);
+        const newHeight = Math.round(image.bitmap.height * scaleFactor);
+        image.resize(newWidth, newHeight);
+        image.quality(currentQuality);
+        resultBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
+        processed = true;
+      }
+    }
+  } else {
+    resultBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+    mimeType = 'image/png';
+
+    // If PNG exceeds maxFileSize, convert to JPEG and compress
+    if (resultBuffer.length > maxFileSize) {
+      outputFormat = 'jpeg';
+      mimeType = 'image/jpeg';
+      currentQuality = quality;
+      image.quality(currentQuality);
+      resultBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
+      processed = true;
+
+      // Reduce quality iteratively if still too large
+      while (resultBuffer.length > maxFileSize && compressionAttempts < maxCompressionAttempts) {
+        compressionAttempts++;
+        currentQuality = Math.max(10, currentQuality - 10);
+        image.quality(currentQuality);
+        resultBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
+
+        // If quality is already at minimum and still too large, scale down the image
+        if (currentQuality === 10 && resultBuffer.length > maxFileSize) {
+          const scaleFactor = Math.sqrt(maxFileSize / resultBuffer.length * 0.9);
+          const newWidth = Math.round(image.bitmap.width * scaleFactor);
+          const newHeight = Math.round(image.bitmap.height * scaleFactor);
+          image.resize(newWidth, newHeight);
+          image.quality(currentQuality);
+          resultBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
+          processed = true;
+        }
+      }
+    }
+  }
+
+  // Return original if no processing was needed and format is PNG
+  if (!processed && outputFormat === 'png' && resultBuffer.length <= maxFileSize) {
+    return {
+      buffer: screenshotBuffer,
+      mimeType: 'image/png',
+      metadata: {
+        width: originalWidth,
+        height: originalHeight,
+        originalSize,
+        finalSize: screenshotBuffer.length,
+        format: 'png',
+        compressed: false,
+        scaled: false
+      }
+    };
+  }
+
+  return {
+    buffer: resultBuffer,
+    mimeType,
+    metadata: {
+      width: image.bitmap.width,
+      height: image.bitmap.height,
+      originalWidth,
+      originalHeight,
+      originalSize,
+      finalSize: resultBuffer.length,
+      format: outputFormat,
+      compressed: outputFormat === 'jpeg' || compressionAttempts > 0,
+      scaled: processed,
+      compressionRatio: Math.round((1 - resultBuffer.length / originalSize) * 100),
+      quality: outputFormat === 'jpeg' ? currentQuality : undefined,
+      compressionAttempts: compressionAttempts > 0 ? compressionAttempts : undefined,
+      autoCompressed: compressionAttempts > 0 || (outputFormat === 'jpeg' && format === 'png')
+    }
+  };
+}
+
+/**
+ * Calculate SSIM (Structural Similarity Index) for image comparison
+ * @param {Uint8ClampedArray} img1Data - First image data
+ * @param {Uint8ClampedArray} img2Data - Second image data
+ * @param {number} width - Image width
+ * @param {number} height - Image height
+ * @returns {number} - SSIM score (0-1, higher is more similar)
+ */
+export function calculateSSIM(img1Data, img2Data, width, height) {
+  if (img1Data.length !== img2Data.length) {
+    return 0;
+  }
+
+  const windowSize = 8;
+  const k1 = 0.01;
+  const k2 = 0.03;
+  const c1 = (k1 * 255) ** 2;
+  const c2 = (k2 * 255) ** 2;
+
+  let ssimSum = 0;
+  let validWindows = 0;
+
+  for (let y = 0; y <= height - windowSize; y += windowSize) {
+    for (let x = 0; x <= width - windowSize; x += windowSize) {
+      let sum1 = 0, sum2 = 0, sum1Sq = 0, sum2Sq = 0, sum12 = 0;
+
+      for (let dy = 0; dy < windowSize; dy++) {
+        for (let dx = 0; dx < windowSize; dx++) {
+          const idx = ((y + dy) * width + (x + dx)) * 4;
+          if (idx + 2 >= img1Data.length) continue;
+
+          const gray1 = (img1Data[idx] * 0.299 + img1Data[idx + 1] * 0.587 + img1Data[idx + 2] * 0.114);
+          const gray2 = (img2Data[idx] * 0.299 + img2Data[idx + 1] * 0.587 + img2Data[idx + 2] * 0.114);
+
+          sum1 += gray1;
+          sum2 += gray2;
+          sum1Sq += gray1 * gray1;
+          sum2Sq += gray2 * gray2;
+          sum12 += gray1 * gray2;
+        }
+      }
+
+      const n = windowSize * windowSize;
+      const mean1 = sum1 / n;
+      const mean2 = sum2 / n;
+      const variance1 = (sum1Sq / n) - (mean1 * mean1);
+      const variance2 = (sum2Sq / n) - (mean2 * mean2);
+      const covariance = (sum12 / n) - (mean1 * mean2);
+
+      const ssim = ((2 * mean1 * mean2 + c1) * (2 * covariance + c2)) /
+        ((mean1 * mean1 + mean2 * mean2 + c1) * (variance1 + variance2 + c2));
+
+      ssimSum += ssim;
+      validWindows++;
+    }
+  }
+
+  return validWindows > 0 ? ssimSum / validWindows : 0;
+}