Improve background mathing.

Author: MrBlankCoding

Public/background.js

@@ -519,55 +519,116 @@ function urlMatchesPattern(url, pattern) {
     // Handle edge cases
     if (pattern === url) return true;
     if (!url || !pattern) return false;
-    
+
+    // Normalize pattern if missing scheme
+    if (!pattern.includes("://")) {
+      pattern = "*://" + pattern;
+    }
+
     // Extract scheme, host, and path from pattern
-    let schemeHost, patternPath;
-    
-    if (pattern.includes("://")) {
-      [schemeHost, ...patternPathParts] = pattern.split("/");
-      patternPath = patternPathParts.length > 0 ? "/" + patternPathParts.join("/") : "/*";
-      
-      // Fix handling of the scheme/host part
-      let [patternScheme, patternHost] = schemeHost.split("://");
-      
-      // Create URL object for the input URL
-      const urlObj = new URL(url);
-      
-      // Handle scheme matching
-      if (patternScheme !== "*" && patternScheme !== urlObj.protocol.slice(0, -1)) {
+    let [schemeHostPart, ...patternPathParts] = pattern.split("/");
+    let patternPath =
+      patternPathParts.length > 0 ? "/" + patternPathParts.join("/") : "/";
+
+    // Fix handling of the scheme/host part
+    let [patternScheme, ...hostParts] = schemeHostPart.split("://");
+    let patternHost = hostParts.join("://"); // In case there's :// in the hostname (unlikely but safe)
+
+    // Create URL object for the input URL
+    const urlObj = new URL(url);
+    const urlPath = urlObj.pathname;
+
+    // Handle scheme matching
+    if (
+      patternScheme !== "*" &&
+      patternScheme !== urlObj.protocol.slice(0, -1)
+    ) {
+      return false;
+    }
+
+    // Handle host matching with wildcards
+    if (patternHost.startsWith("*.")) {
+      // *.domain.com pattern - match domain or any subdomain
+      const domain = patternHost.slice(2);
+      if (
+        !(urlObj.hostname === domain || urlObj.hostname.endsWith("." + domain))
+      ) {
         return false;
       }
-      
-      // Handle host matching with wildcard
-      if (patternHost.startsWith("*.")) {
-        if (!urlObj.hostname.endsWith(patternHost.slice(2))) {
-          return false;
-        }
-      } else if (patternHost !== "*" && patternHost !== urlObj.hostname) {
+    } else if (patternHost.includes("*")) {
+      // Handle other wildcards in hostname
+      const hostRegex = new RegExp(
+        "^" + patternHost.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+      );
+      if (!hostRegex.test(urlObj.hostname)) {
         return false;
       }
-      
-      // Handle path matching
-      if (patternPath === "/*") {
-        return true; // Match any path
+    } else if (patternHost !== "*" && patternHost !== urlObj.hostname) {
+      // Direct hostname match
+      return false;
+    }
+
+    // If pattern path is empty or just "/" or "/*", match any path
+    if (patternPath === "/" || patternPath === "/*") {
+      return true;
+    }
+
+    // Handle special case for /** at the end
+    if (patternPath.endsWith("/**")) {
+      const basePath = patternPath.slice(0, -3);
+      return urlPath === basePath || urlPath.startsWith(basePath);
+    }
+
+    // Handle path matching with both * and ** wildcards
+    const pathSegments = patternPath
+      .split("/")
+      .filter((segment) => segment !== "");
+    const urlSegments = urlPath.split("/").filter((segment) => segment !== "");
+
+    // Simple case: if pattern is just /* match any single-level path
+    if (pathSegments.length === 1 && pathSegments[0] === "*") {
+      return true;
+    }
+
+    let pathRegexParts = ["^"];
+    let i = 0;
+
+    for (i = 0; i < pathSegments.length; i++) {
+      const segment = pathSegments[i];
+
+      // Handle ** wildcard (matches across multiple path segments)
+      if (segment === "**") {
+        // If this is the last segment, match anything that follows
+        if (i === pathSegments.length - 1) {
+          pathRegexParts.push(".*");
+          break;
+        }
+
+        // Otherwise, match anything until we find the next segment
+        const nextSegment = pathSegments[i + 1];
+        const nextSegmentRegex = nextSegment
+          .replace(/\*/g, "[^/]*")
+          .replace(/\./g, "\\.");
+
+        pathRegexParts.push(`(?:.*?\\/)?${nextSegmentRegex}`);
+        i++; // Skip the next segment as we've already included it
       } else {
-        // Convert pattern path to regex pattern
-        const pathPattern = patternPath
-          .split("/")
-          .map(segment => {
-            if (segment === "*") return "[^/]*";
-            if (segment.includes("*")) return segment.replace(/\*/g, "[^/]*");
-            return segment;
-          })
-          .join("/");
-          
-        const pathRegex = new RegExp(`^${pathPattern}$`);
-        return pathRegex.test(urlObj.pathname);
+        // Handle regular segment with potential * wildcards
+        const segmentRegex = segment
+          .replace(/\*/g, "[^/]*")
+          .replace(/\./g, "\\.");
+        if (i === 0) {
+          pathRegexParts.push(`\\/?${segmentRegex}`); // Make the first slash optional
+        } else {
+          pathRegexParts.push(`\\/${segmentRegex}`);
+        }
       }
-    } else {
-      // Handle patterns without scheme
-      return url.includes(pattern);
     }
+
+    pathRegexParts.push("$");
+    const pathRegex = new RegExp(pathRegexParts.join(""));
+
+    return pathRegex.test(urlPath);
   } catch (error) {
     console.warn("URL matching error:", error);
     return false;

Public/popup.js

@@ -257,9 +257,6 @@ function urlMatchesPattern(url, script) {
       if (!pattern) return false;
       if (pattern === url) return true;
 
-      // Handle exact match
-      if (pattern === url) return true;
-
       // Normalize pattern if missing scheme
       if (!pattern.includes("://")) {
         pattern = "*://" + pattern;
@@ -296,23 +293,20 @@ function urlMatchesPattern(url, script) {
         if (!(urlHost === domain || urlHost.endsWith("." + domain))) {
           return false;
         }
-      } else if (hostPattern !== "*" && hostPattern !== urlHost) {
-        // Handle direct hostname match or * wildcard
-        if (hostPattern.includes("*")) {
-          // Convert * to regex for partial host matching
-          const hostRegex = new RegExp(
-            "^" + hostPattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
-          );
-          if (!hostRegex.test(urlHost)) {
-            return false;
-          }
-        } else {
+      } else if (hostPattern.includes("*")) {
+        // Convert * to regex for partial host matching
+        const hostRegex = new RegExp(
+          "^" + hostPattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+        );
+        if (!hostRegex.test(urlHost)) {
           return false;
         }
+      } else if (hostPattern !== "*" && hostPattern !== urlHost) {
+        return false;
       }
 
-      // If no path in pattern but URL has path, still consider it a match
-      if (!pathPattern) {
+      // If no path in pattern or just wildcard, consider it a match
+      if (!pathPattern || pathPattern === "*") {
         return true;
       }