vite-plugin-sri4 1.9.0 → 3.0.0

package/README.md

@@ -16,6 +16,7 @@ A Vite plugin to generate Subresource Integrity (SRI) hashes for your assets dur
 - [Best Practices](#best-practices)
 - [Troubleshooting](#troubleshooting)
 - [Contributing](#contributing)
+- [Inspiration](#inspiration)
 - [License](#license)
 
 ## Features
@@ -26,6 +27,7 @@ A Vite plugin to generate Subresource Integrity (SRI) hashes for your assets dur
 - **Bypass Domains:** Option to specify domains to bypass SRI injection.
 - **Missing Asset Handling:** Configurable warning suppression for missing assets.
 - **Robust Content Support:** Handles various content types including strings, Buffer, and Uint8Array.
+- **Vite Compatibility:** Compatible with Vite 6.0 and 7.0.
 
 ## Installation
 
@@ -178,6 +180,14 @@ Please make sure to:
 - Follow the existing code style
 - Update the CHANGELOG.md
 
+## Inspiration
+
+This project was inspired by [vite-plugin-sri3](https://github.com/yoyo930021/vite-plugin-sri3), which provides subresource integrity for Vite. We've built upon its foundation to create an enhanced version with additional features and improved compatibility.
+
+Other projects that influenced this work:
+- [rollup-plugin-sri](https://github.com/JonasKruckenberg/rollup-plugin-sri)
+- [@small-tech/vite-plugin-sri](https://github.com/small-tech/vite-plugin-sri)
+
 ## License
 
 This project is licensed under the MIT License - see the LICENSE file for details.

package/dist/index.cjs

@@ -1,81 +1,197 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var crypto = require('crypto');
 var path = require('path');
 var fetch = require('cross-fetch');
 
+// Constants definition
 const VITE_INTERNAL_ANALYSIS_PLUGIN = 'vite:build-import-analysis';
+const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_HASH_ALGORITHM = 'sha384';
+const DEFAULT_PLUGIN_NAME = 'vite-plugin-sri4';
+
+// Optimized regex patterns for better readability and efficiency
 const HTML_PATTERNS = {
   script: {
-    regex: /<script[^<>]*['"]*src['"]*=['"]*([^ '"]+)['"]*[^<>]*><\/script>/g,
+    regex: /<script\b[^>]*?\bsrc\s*=\s*["']([^"']+)["'][^>]*><\/script>/g,
     endOffset: 10
   },
   stylesheet: {
-    regex: /<link[^<>]*['"]*rel['"]*=['"]*stylesheet['"]*[^<>]+['"]*href['"]*=['"]([^^ '"]+)['"][^<>]*>/g,
+    regex: /<link\b[^>]*?\brel\s*=\s*["']stylesheet["'][^>]*?\bhref\s*=\s*["']([^"']+)["'][^>]*>/g,
     endOffset: 1
   },
   modulepreload: {
-    regex: /<link[^<>]*['"]*rel['"]*=['"]*modulepreload['"]*[^<>]+['"]*href['"]*=['"]([^^ '"]+)['"][^<>]*>/g,
+    regex: /<link\b[^>]*?\brel\s*=\s*["']modulepreload["'][^>]*?\bhref\s*=\s*["']([^"']+)["'][^>]*>/g,
     endOffset: 1
   }
 };
 
-const urlSupportCache = new Map();
+// Extended caching mechanism with expiration time
+class ResourceCache {
+  constructor(ttl = 3600000) { // Default cache for 1 hour
+    this.cache = new Map();
+    this.ttl = ttl;
+  }
+
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return undefined
+
+    // Check if expired
+    if (Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return undefined
+    }
+
+    return item.value
+  }
+
+  set(key, value) {
+    this.cache.set(key, {
+      value,
+      expiry: Date.now() + this.ttl
+    });
+  }
+
+  has(key) {
+    return this.get(key) !== undefined
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+}
+
+const urlSupportCache = new ResourceCache();
+const resourceCache = new ResourceCache();
 
+// Check if URL is from a bypass domain
 function isUrlFromBypassDomain(url, bypassDomains = []) {
-  if (!url.startsWith('http')) return false
+  if (!url || typeof url !== 'string' || !url.startsWith('http')) return false
+
   try {
     const urlObj = new URL(url);
     return bypassDomains.some(domain =>
       urlObj.hostname === domain || urlObj.hostname.endsWith(`.${domain}`)
     )
-  } catch {
+  } catch (error) {
+    console.warn(`[${DEFAULT_PLUGIN_NAME}] Invalid URL: ${url}`, error);
     return false
   }
 }
 
-async function checkResourceSupport(url) {
+// Resource check with retry mechanism
+async function checkResourceSupport(url, retries = 2) {
   if (urlSupportCache.has(url)) {
     return urlSupportCache.get(url)
   }
 
-  try {
-    const response = await fetch(url, {
-      method: 'HEAD',
-      timeout: 5000
-    });
-    const corsHeader = response.headers.get('access-control-allow-origin');
-    const isSupported = response.ok && (corsHeader === '*' || corsHeader?.includes('*'));
-    urlSupportCache.set(url, isSupported);
-    return isSupported
-  } catch {
-    urlSupportCache.set(url, false);
-    return false
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+
+      const response = await fetch(url, {
+        method: 'HEAD',
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      const corsHeader = response.headers.get('access-control-allow-origin');
+      const isSupported = response.ok && (corsHeader === '*' || corsHeader?.includes('*'));
+      urlSupportCache.set(url, isSupported);
+      return isSupported
+    } catch (error) {
+      lastError = error;
+      if (error.name === 'AbortError') {
+        console.warn(`[${DEFAULT_PLUGIN_NAME}] Resource check timed out: ${url}`);
+        break // Don't retry timeouts
+      }
+
+      // Don't wait after the last failed attempt
+      if (attempt < retries) {
+        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+      }
+    }
   }
+
+  console.warn(`[${DEFAULT_PLUGIN_NAME}] Failed to check resource support: ${url}`, lastError);
+  urlSupportCache.set(url, false);
+  return false
 }
 
-async function fetchResource(url) {
-  try {
-    const response = await fetch(url, { timeout: 5000 });
-    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`)
-    return new Uint8Array(await response.arrayBuffer())
-  } catch (error) {
-    console.warn(`[vite-plugin-sri4] Failed to fetch external resource: ${url}`, error);
-    return null
+// Optimized resource fetching function with retry mechanism and caching
+async function fetchResource(url, retries = 1) {
+  // Check cache
+  if (resourceCache.has(url)) {
+    return resourceCache.get(url)
+  }
+
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+
+      const response = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`)
+      }
+
+      const data = new Uint8Array(await response.arrayBuffer());
+      resourceCache.set(url, data);
+      return data
+    } catch (error) {
+      lastError = error;
+      if (error.name === 'AbortError') {
+        console.warn(`[${DEFAULT_PLUGIN_NAME}] Resource fetch timed out: ${url}`);
+        break // Don't retry timeouts
+      }
+
+      if (attempt < retries) {
+        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+      }
+    }
   }
+
+  console.warn(`[${DEFAULT_PLUGIN_NAME}] Failed to fetch external resource: ${url}`, lastError);
+  return null
 }
 
 function createTransformer(options, config) {
-  const { ignoreMissingAsset, bypassDomains, hashAlgorithm = 'sha384' } = options;
+  const {
+    ignoreMissingAsset,
+    bypassDomains,
+    hashAlgorithm = DEFAULT_HASH_ALGORITHM
+  } = options;
 
+  // Improved method for getting bundle keys
   const getBundleKey = (htmlPath, url) => {
+    // Handle absolute path URLs
+    if (url.startsWith('/')) {
+      // Remove leading slash to match keys in bundle
+      return url.substring(1)
+    }
+
+    // Handle relative paths (when config.base is relative)
     if (config.base === './' || config.base === '') {
-      return path.posix.resolve(htmlPath, url)
+      return path.posix.resolve(path.posix.dirname(htmlPath), url)
     }
-    return url.replace(config.base, '')
+
+    // Handle other cases, remove base prefix from URL
+    return url.startsWith(config.base)
+      ? url.substring(config.base.length)
+      : url
   };
 
   const calculateIntegrity = async (bundle, htmlPath, url) => {
+    // Skip specified domains
     if (isUrlFromBypassDomain(url, bypassDomains)) {
       return null
     }
@@ -87,41 +203,93 @@ function createTransformer(options, config) {
       source = await fetchResource(url);
       if (!source) return null
     } else {
-      const bundleItem = bundle[getBundleKey(htmlPath, url)];
+      const bundleKey = getBundleKey(htmlPath, url);
+      const bundleItem = bundle[bundleKey];
+
       if (!bundleItem) {
-        if (ignoreMissingAsset) return null
-        throw new Error(`Asset ${url} not found in bundle`)
+        // Try to find a matching item with more flexible matching
+        const possibleMatch = Object.keys(bundle).find(key =>
+          key.endsWith(bundleKey) || bundleKey.endsWith(key)
+        );
+
+        if (possibleMatch) {
+          source = bundle[possibleMatch].type === 'chunk'
+            ? bundle[possibleMatch].code
+            : bundle[possibleMatch].source;
+        } else if (ignoreMissingAsset) {
+          console.warn(`[${DEFAULT_PLUGIN_NAME}] Asset not found in bundle: ${url} (path: ${htmlPath}, key: ${bundleKey})`);
+          return null
+        } else {
+          throw new Error(`Asset ${url} not found in bundle (path: ${htmlPath}, key: ${bundleKey})`)
+        }
+      } else {
+        source = bundleItem.type === 'chunk' ? bundleItem.code : bundleItem.source;
       }
-      source = bundleItem.type === 'chunk' ? bundleItem.code : bundleItem.source;
     }
 
-    return `${hashAlgorithm}-${crypto.createHash(hashAlgorithm).update(source).digest('base64')}`
+    // Ensure source is a Uint8Array or string
+    if (!source) return null
+
+    if (typeof source === 'string') {
+      return `${hashAlgorithm}-${crypto.createHash(hashAlgorithm).update(source).digest('base64')}`
+    }
+
+    return `${hashAlgorithm}-${crypto.createHash(hashAlgorithm).update(Buffer.from(source)).digest('base64')}`
   };
 
   const transformHTML = async (bundle, htmlPath, html) => {
+    if (!html || typeof html !== 'string') {
+      console.warn(`[${DEFAULT_PLUGIN_NAME}] Invalid HTML content for ${htmlPath}`);
+      return html
+    }
+
     const changes = [];
 
-    for (const { regex, endOffset } of Object.values(HTML_PATTERNS)) {
-      const matches = [...html.matchAll(regex)];
-      for (const match of matches) {
-        const [, url] = match;
-        const end = match.index + match[0].length;
-
-        const integrity = await calculateIntegrity(bundle, htmlPath, url);
-        if (integrity) {
-          changes.push({
-            integrity,
-            position: end - endOffset
-          });
-        }
-      }
-    }
+    // Collect changes from all patterns in parallel
+    await Promise.all(
+      Object.values(HTML_PATTERNS).map(async ({ regex, endOffset }) => {
+        const matches = [...html.matchAll(regex)];
+
+        // Process each match in parallel
+        const matchResults = await Promise.all(
+          matches.map(async match => {
+            const [, url] = match;
+            if (!url) return null
+
+            const end = match.index + match[0].length;
+            const integrity = await calculateIntegrity(bundle, htmlPath, url);
+
+            if (integrity) {
+              return {
+                integrity,
+                position: end - endOffset,
+                url // For logging
+              }
+            }
+            return null
+          })
+        );
+
+        // Filter out null results
+        matchResults.filter(Boolean).forEach(result => changes.push(result));
+      })
+    );
 
+    // Sort by position in descending order to insert from back to front (won't affect insertion points ahead)
     changes.sort((a, b) => b.position - a.position);
 
-    for (const { integrity, position } of changes) {
+    // Check if identical integrity attributes already exist to avoid duplicates
+    for (const { integrity, position, url } of changes) {
       const insertText = ` integrity="${integrity}"`;
+
+      // Check if integrity attribute already exists
+      const segment = html.slice(Math.max(0, position - 100), position + 100);
+      if (segment.includes(`integrity="${integrity}"`)) {
+        continue // Skip elements that already have the same integrity
+      }
+
       html = html.slice(0, position) + insertText + html.slice(position);
+      console.debug(`[${DEFAULT_PLUGIN_NAME}] Added integrity for: ${url}`);
     }
 
     return html
@@ -134,13 +302,37 @@ function sri(options = {}) {
   const {
     ignoreMissingAsset = false,
     bypassDomains = [],
-    hashAlgorithm = 'sha384'
+    hashAlgorithm = DEFAULT_HASH_ALGORITHM,
+    logLevel = 'warn'
   } = options;
 
+  // Adjust log level
+  const originalConsoleWarn = console.warn;
+  const originalConsoleDebug = console.debug;
+
+  if (logLevel === 'error') {
+    console.warn = () => {};
+    console.debug = () => {};
+  } else if (logLevel === 'warn') {
+    console.debug = () => {};
+  }
+
   return {
-    name: 'vite-plugin-sri4',
+    name: DEFAULT_PLUGIN_NAME,
     enforce: 'post',
     apply: 'build',
+
+    // Cleanup work
+    buildEnd() {
+      // Restore console functions
+      console.warn = originalConsoleWarn;
+      console.debug = originalConsoleDebug;
+
+      // Clear caches
+      urlSupportCache.clear();
+      resourceCache.clear();
+    },
+
     configResolved(config) {
       const transformer = createTransformer({
         ignoreMissingAsset,
@@ -155,16 +347,32 @@ function sri(options = {}) {
             /\.html?$/.test(chunk.fileName)
         );
 
+        if (htmlFiles.length === 0) {
+          console.debug(`[${DEFAULT_PLUGIN_NAME}] No HTML files found in bundle`);
+          return
+        }
+
+        // Process all HTML files in parallel
         await Promise.all(
           htmlFiles.map(async ([name, chunk]) => {
-            chunk.source = await transformer.transformHTML(bundle, name, chunk.source.toString());
+            try {
+              const originalContent = chunk.source.toString();
+              chunk.source = await transformer.transformHTML(bundle, name, originalContent);
+
+              if (originalContent !== chunk.source) {
+                console.debug(`[${DEFAULT_PLUGIN_NAME}] SRI attributes added to ${name}`);
+              }
+            } catch (error) {
+              console.warn(`[${DEFAULT_PLUGIN_NAME}] Error processing ${name}:`, error);
+              // Keep original content on error
+            }
           })
         );
       };
 
       const plugin = config.plugins.find(p => p.name === VITE_INTERNAL_ANALYSIS_PLUGIN);
       if (!plugin) {
-        throw new Error('vite-plugin-sri4 requires Vite 2.0.0 or higher')
+        throw new Error(`[${DEFAULT_PLUGIN_NAME}] requires Vite 2.0.0 or higher`)
       }
 
       if (typeof plugin.generateBundle === 'object' && plugin.generateBundle.handler) {
@@ -184,4 +392,5 @@ function sri(options = {}) {
   }
 }
 
+exports.default = sri;
 exports.sri = sri;

package/dist/index.js

@@ -2,78 +2,192 @@ import { createHash } from 'crypto';
 import path from 'path';
 import fetch from 'cross-fetch';
 
+// Constants definition
 const VITE_INTERNAL_ANALYSIS_PLUGIN = 'vite:build-import-analysis';
+const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_HASH_ALGORITHM = 'sha384';
+const DEFAULT_PLUGIN_NAME = 'vite-plugin-sri4';
+
+// Optimized regex patterns for better readability and efficiency
 const HTML_PATTERNS = {
   script: {
-    regex: /<script[^<>]*['"]*src['"]*=['"]*([^ '"]+)['"]*[^<>]*><\/script>/g,
+    regex: /<script\b[^>]*?\bsrc\s*=\s*["']([^"']+)["'][^>]*><\/script>/g,
     endOffset: 10
   },
   stylesheet: {
-    regex: /<link[^<>]*['"]*rel['"]*=['"]*stylesheet['"]*[^<>]+['"]*href['"]*=['"]([^^ '"]+)['"][^<>]*>/g,
+    regex: /<link\b[^>]*?\brel\s*=\s*["']stylesheet["'][^>]*?\bhref\s*=\s*["']([^"']+)["'][^>]*>/g,
     endOffset: 1
   },
   modulepreload: {
-    regex: /<link[^<>]*['"]*rel['"]*=['"]*modulepreload['"]*[^<>]+['"]*href['"]*=['"]([^^ '"]+)['"][^<>]*>/g,
+    regex: /<link\b[^>]*?\brel\s*=\s*["']modulepreload["'][^>]*?\bhref\s*=\s*["']([^"']+)["'][^>]*>/g,
     endOffset: 1
   }
 };
 
-const urlSupportCache = new Map();
+// Extended caching mechanism with expiration time
+class ResourceCache {
+  constructor(ttl = 3600000) { // Default cache for 1 hour
+    this.cache = new Map();
+    this.ttl = ttl;
+  }
+
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return undefined
+
+    // Check if expired
+    if (Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return undefined
+    }
+
+    return item.value
+  }
+
+  set(key, value) {
+    this.cache.set(key, {
+      value,
+      expiry: Date.now() + this.ttl
+    });
+  }
+
+  has(key) {
+    return this.get(key) !== undefined
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+}
+
+const urlSupportCache = new ResourceCache();
+const resourceCache = new ResourceCache();
 
+// Check if URL is from a bypass domain
 function isUrlFromBypassDomain(url, bypassDomains = []) {
-  if (!url.startsWith('http')) return false
+  if (!url || typeof url !== 'string' || !url.startsWith('http')) return false
+
   try {
     const urlObj = new URL(url);
     return bypassDomains.some(domain =>
       urlObj.hostname === domain || urlObj.hostname.endsWith(`.${domain}`)
     )
-  } catch {
+  } catch (error) {
+    console.warn(`[${DEFAULT_PLUGIN_NAME}] Invalid URL: ${url}`, error);
     return false
   }
 }
 
-async function checkResourceSupport(url) {
+// Resource check with retry mechanism
+async function checkResourceSupport(url, retries = 2) {
   if (urlSupportCache.has(url)) {
     return urlSupportCache.get(url)
   }
 
-  try {
-    const response = await fetch(url, {
-      method: 'HEAD',
-      timeout: 5000
-    });
-    const corsHeader = response.headers.get('access-control-allow-origin');
-    const isSupported = response.ok && (corsHeader === '*' || corsHeader?.includes('*'));
-    urlSupportCache.set(url, isSupported);
-    return isSupported
-  } catch {
-    urlSupportCache.set(url, false);
-    return false
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+
+      const response = await fetch(url, {
+        method: 'HEAD',
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      const corsHeader = response.headers.get('access-control-allow-origin');
+      const isSupported = response.ok && (corsHeader === '*' || corsHeader?.includes('*'));
+      urlSupportCache.set(url, isSupported);
+      return isSupported
+    } catch (error) {
+      lastError = error;
+      if (error.name === 'AbortError') {
+        console.warn(`[${DEFAULT_PLUGIN_NAME}] Resource check timed out: ${url}`);
+        break // Don't retry timeouts
+      }
+
+      // Don't wait after the last failed attempt
+      if (attempt < retries) {
+        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+      }
+    }
   }
+
+  console.warn(`[${DEFAULT_PLUGIN_NAME}] Failed to check resource support: ${url}`, lastError);
+  urlSupportCache.set(url, false);
+  return false
 }
 
-async function fetchResource(url) {
-  try {
-    const response = await fetch(url, { timeout: 5000 });
-    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`)
-    return new Uint8Array(await response.arrayBuffer())
-  } catch (error) {
-    console.warn(`[vite-plugin-sri4] Failed to fetch external resource: ${url}`, error);
-    return null
+// Optimized resource fetching function with retry mechanism and caching
+async function fetchResource(url, retries = 1) {
+  // Check cache
+  if (resourceCache.has(url)) {
+    return resourceCache.get(url)
   }
+
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+
+      const response = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`)
+      }
+
+      const data = new Uint8Array(await response.arrayBuffer());
+      resourceCache.set(url, data);
+      return data
+    } catch (error) {
+      lastError = error;
+      if (error.name === 'AbortError') {
+        console.warn(`[${DEFAULT_PLUGIN_NAME}] Resource fetch timed out: ${url}`);
+        break // Don't retry timeouts
+      }
+
+      if (attempt < retries) {
+        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+      }
+    }
+  }
+
+  console.warn(`[${DEFAULT_PLUGIN_NAME}] Failed to fetch external resource: ${url}`, lastError);
+  return null
 }
 
 function createTransformer(options, config) {
-  const { ignoreMissingAsset, bypassDomains, hashAlgorithm = 'sha384' } = options;
+  const {
+    ignoreMissingAsset,
+    bypassDomains,
+    hashAlgorithm = DEFAULT_HASH_ALGORITHM
+  } = options;
 
+  // Improved method for getting bundle keys
   const getBundleKey = (htmlPath, url) => {
+    // Handle absolute path URLs
+    if (url.startsWith('/')) {
+      // Remove leading slash to match keys in bundle
+      return url.substring(1)
+    }
+
+    // Handle relative paths (when config.base is relative)
     if (config.base === './' || config.base === '') {
-      return path.posix.resolve(htmlPath, url)
+      return path.posix.resolve(path.posix.dirname(htmlPath), url)
     }
-    return url.replace(config.base, '')
+
+    // Handle other cases, remove base prefix from URL
+    return url.startsWith(config.base)
+      ? url.substring(config.base.length)
+      : url
   };
 
   const calculateIntegrity = async (bundle, htmlPath, url) => {
+    // Skip specified domains
     if (isUrlFromBypassDomain(url, bypassDomains)) {
       return null
     }
@@ -85,41 +199,93 @@ function createTransformer(options, config) {
       source = await fetchResource(url);
       if (!source) return null
     } else {
-      const bundleItem = bundle[getBundleKey(htmlPath, url)];
+      const bundleKey = getBundleKey(htmlPath, url);
+      const bundleItem = bundle[bundleKey];
+
       if (!bundleItem) {
-        if (ignoreMissingAsset) return null
-        throw new Error(`Asset ${url} not found in bundle`)
+        // Try to find a matching item with more flexible matching
+        const possibleMatch = Object.keys(bundle).find(key =>
+          key.endsWith(bundleKey) || bundleKey.endsWith(key)
+        );
+
+        if (possibleMatch) {
+          source = bundle[possibleMatch].type === 'chunk'
+            ? bundle[possibleMatch].code
+            : bundle[possibleMatch].source;
+        } else if (ignoreMissingAsset) {
+          console.warn(`[${DEFAULT_PLUGIN_NAME}] Asset not found in bundle: ${url} (path: ${htmlPath}, key: ${bundleKey})`);
+          return null
+        } else {
+          throw new Error(`Asset ${url} not found in bundle (path: ${htmlPath}, key: ${bundleKey})`)
+        }
+      } else {
+        source = bundleItem.type === 'chunk' ? bundleItem.code : bundleItem.source;
       }
-      source = bundleItem.type === 'chunk' ? bundleItem.code : bundleItem.source;
     }
 
-    return `${hashAlgorithm}-${createHash(hashAlgorithm).update(source).digest('base64')}`
+    // Ensure source is a Uint8Array or string
+    if (!source) return null
+
+    if (typeof source === 'string') {
+      return `${hashAlgorithm}-${createHash(hashAlgorithm).update(source).digest('base64')}`
+    }
+
+    return `${hashAlgorithm}-${createHash(hashAlgorithm).update(Buffer.from(source)).digest('base64')}`
   };
 
   const transformHTML = async (bundle, htmlPath, html) => {
+    if (!html || typeof html !== 'string') {
+      console.warn(`[${DEFAULT_PLUGIN_NAME}] Invalid HTML content for ${htmlPath}`);
+      return html
+    }
+
     const changes = [];
 
-    for (const { regex, endOffset } of Object.values(HTML_PATTERNS)) {
-      const matches = [...html.matchAll(regex)];
-      for (const match of matches) {
-        const [, url] = match;
-        const end = match.index + match[0].length;
-
-        const integrity = await calculateIntegrity(bundle, htmlPath, url);
-        if (integrity) {
-          changes.push({
-            integrity,
-            position: end - endOffset
-          });
-        }
-      }
-    }
+    // Collect changes from all patterns in parallel
+    await Promise.all(
+      Object.values(HTML_PATTERNS).map(async ({ regex, endOffset }) => {
+        const matches = [...html.matchAll(regex)];
+
+        // Process each match in parallel
+        const matchResults = await Promise.all(
+          matches.map(async match => {
+            const [, url] = match;
+            if (!url) return null
+
+            const end = match.index + match[0].length;
+            const integrity = await calculateIntegrity(bundle, htmlPath, url);
+
+            if (integrity) {
+              return {
+                integrity,
+                position: end - endOffset,
+                url // For logging
+              }
+            }
+            return null
+          })
+        );
+
+        // Filter out null results
+        matchResults.filter(Boolean).forEach(result => changes.push(result));
+      })
+    );
 
+    // Sort by position in descending order to insert from back to front (won't affect insertion points ahead)
     changes.sort((a, b) => b.position - a.position);
 
-    for (const { integrity, position } of changes) {
+    // Check if identical integrity attributes already exist to avoid duplicates
+    for (const { integrity, position, url } of changes) {
       const insertText = ` integrity="${integrity}"`;
+
+      // Check if integrity attribute already exists
+      const segment = html.slice(Math.max(0, position - 100), position + 100);
+      if (segment.includes(`integrity="${integrity}"`)) {
+        continue // Skip elements that already have the same integrity
+      }
+
       html = html.slice(0, position) + insertText + html.slice(position);
+      console.debug(`[${DEFAULT_PLUGIN_NAME}] Added integrity for: ${url}`);
     }
 
     return html
@@ -132,13 +298,37 @@ function sri(options = {}) {
   const {
     ignoreMissingAsset = false,
     bypassDomains = [],
-    hashAlgorithm = 'sha384'
+    hashAlgorithm = DEFAULT_HASH_ALGORITHM,
+    logLevel = 'warn'
   } = options;
 
+  // Adjust log level
+  const originalConsoleWarn = console.warn;
+  const originalConsoleDebug = console.debug;
+
+  if (logLevel === 'error') {
+    console.warn = () => {};
+    console.debug = () => {};
+  } else if (logLevel === 'warn') {
+    console.debug = () => {};
+  }
+
   return {
-    name: 'vite-plugin-sri4',
+    name: DEFAULT_PLUGIN_NAME,
     enforce: 'post',
     apply: 'build',
+
+    // Cleanup work
+    buildEnd() {
+      // Restore console functions
+      console.warn = originalConsoleWarn;
+      console.debug = originalConsoleDebug;
+
+      // Clear caches
+      urlSupportCache.clear();
+      resourceCache.clear();
+    },
+
     configResolved(config) {
       const transformer = createTransformer({
         ignoreMissingAsset,
@@ -153,16 +343,32 @@ function sri(options = {}) {
             /\.html?$/.test(chunk.fileName)
         );
 
+        if (htmlFiles.length === 0) {
+          console.debug(`[${DEFAULT_PLUGIN_NAME}] No HTML files found in bundle`);
+          return
+        }
+
+        // Process all HTML files in parallel
         await Promise.all(
           htmlFiles.map(async ([name, chunk]) => {
-            chunk.source = await transformer.transformHTML(bundle, name, chunk.source.toString());
+            try {
+              const originalContent = chunk.source.toString();
+              chunk.source = await transformer.transformHTML(bundle, name, originalContent);
+
+              if (originalContent !== chunk.source) {
+                console.debug(`[${DEFAULT_PLUGIN_NAME}] SRI attributes added to ${name}`);
+              }
+            } catch (error) {
+              console.warn(`[${DEFAULT_PLUGIN_NAME}] Error processing ${name}:`, error);
+              // Keep original content on error
+            }
           })
         );
       };
 
       const plugin = config.plugins.find(p => p.name === VITE_INTERNAL_ANALYSIS_PLUGIN);
       if (!plugin) {
-        throw new Error('vite-plugin-sri4 requires Vite 2.0.0 or higher')
+        throw new Error(`[${DEFAULT_PLUGIN_NAME}] requires Vite 2.0.0 or higher`)
       }
 
       if (typeof plugin.generateBundle === 'object' && plugin.generateBundle.handler) {
@@ -182,4 +388,4 @@ function sri(options = {}) {
   }
 }
 
-export { sri };
+export { sri as default, sri };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-sri4",
-  "version": "1.9.0",
+  "version": "3.0.0",
   "description": "A Vite plugin to generate Subresource Integrity (SRI) hashes for output files.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -27,17 +27,17 @@
     "cross-fetch": "^4.1.0"
   },
   "peerDependencies": {
-    "vite": "^4.0.0 || ^5.0.0 || ^6.0.0"
+    "vite": "^6.0.0 || ^7.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@vitest/coverage-v8": "^1.2.2",
+    "@vitest/coverage-v8": "^3.2.4",
     "cross-fetch": "^4.0.0",
+    "memfs": "^4.6.0",
     "rollup": "^4.9.6",
-    "vite": "^5.0.12",
-    "vitest": "^1.2.2",
-    "memfs": "^4.6.0"
+    "vite": "^7.0.0",
+    "vitest": "^3.2.4"
   },
   "keywords": [
     "vite",