webext-patterns 1.5.1 → 2.0.0

package/index.js

@@ -1,71 +1,93 @@
-import escapeStringRegexp from 'escape-string-regexp';
-// Copied from https://github.com/mozilla/gecko-dev/blob/073cc24f53d0cf31403121d768812146e597cc9d/toolkit/components/extensions/schemas/manifest.json#L487-L491
-export const patternValidationRegex = /^(https?|wss?|file|ftp|\*):\/\/(\*|\*\.[^*/]+|[^*/]+)\/.*$|^file:\/\/\/.*$|^resource:\/\/(\*|\*\.[^*/]+|[^*/]+)\/.*$|^about:/;
-const isFirefox = globalThis.navigator?.userAgent.includes('Firefox/');
-export const allStarsRegex = isFirefox
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var _a;
+exports.__esModule = true;
+exports.removeRedundantPatterns = exports.globToRegex = exports.patternToRegex = exports.getMatchingPatterns = exports.testPatterns = exports.isValidPattern = exports.assertValidPattern = exports.allUrlsRegex = exports.allStarsRegex = exports.patternValidationRegex = void 0;
+// Copied from https://github.com/mozilla/gecko-dev/blob/5836a062726f715fda621338a17b51aff30d0a8c/toolkit/components/extensions/schemas/manifest.json#L729-L741
+exports.patternValidationRegex = /^(https?|wss?|file|ftp|\*):\/\/(\*|\*\.[^*/:]+|[^*/:]+)\/.*$|^file:\/\/\/.*$|^about:/;
+var isFirefox = (_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.userAgent.includes('Firefox/');
+exports.allStarsRegex = isFirefox
     ? /^(https?|wss?):[/][/][^/]+([/].*)?$/
     : /^https?:[/][/][^/]+([/].*)?$/;
-export const allUrlsRegex = /^(https?|file|ftp):[/]+/;
-export function assertValidPattern(matchPattern) {
+exports.allUrlsRegex = /^(https?|file|ftp):[/]+/;
+function assertValidPattern(matchPattern) {
     if (!isValidPattern(matchPattern)) {
         throw new Error(matchPattern + ' is an invalid pattern. See https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Match_patterns for more info.');
     }
 }
-export function isValidPattern(matchPattern) {
-    return matchPattern === '<all_urls>' || patternValidationRegex.test(matchPattern);
+exports.assertValidPattern = assertValidPattern;
+function isValidPattern(matchPattern) {
+    return matchPattern === '<all_urls>' || exports.patternValidationRegex.test(matchPattern);
 }
-export function doesUrlMatchPatterns(url, ...patterns) {
-    if (patterns.includes('<all_urls>') && allUrlsRegex.test(url)) {
+exports.isValidPattern = isValidPattern;
+function testPatterns(url, patterns) {
+    if (patterns.includes('<all_urls>') && exports.allUrlsRegex.test(url)) {
         return true;
     }
-    if (patterns.includes('*://*/*') && allStarsRegex.test(url)) {
+    if (patterns.includes('*://*/*') && exports.allStarsRegex.test(url)) {
         return true;
     }
-    for (const pattern of patterns) {
+    for (var _i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
+        var pattern = patterns_1[_i];
         if (patternToRegex(pattern).test(url)) {
             return true;
         }
     }
     return false;
 }
-export function findMatchingPatterns(url, ...patterns) {
-    return patterns.filter(pattern => doesUrlMatchPatterns(url, pattern));
+exports.testPatterns = testPatterns;
+function getMatchingPatterns(url, patterns) {
+    return patterns.filter(function (pattern) { return testPatterns(url, [pattern]); });
 }
+exports.getMatchingPatterns = getMatchingPatterns;
 function getRawPatternRegex(matchPattern) {
     assertValidPattern(matchPattern);
     // Host undefined for file:///
-    let [, protocol, host = '', pathname] = matchPattern.split(/(^[^:]+:[/][/])([^/]+)?/);
+    var _a = matchPattern.split(/(^[^:]+:[/][/])([^/]+)?/), protocol = _a[1], _b = _a[2], host = _b === void 0 ? '' : _b, pathname = _a[3];
     protocol = protocol
         .replace('*', isFirefox ? '(https?|wss?)' : 'https?') // Protocol wildcard
         .replaceAll(/[/]/g, '[/]'); // Escape slashes
     if (host === '*') {
         host = '[^/]+';
     }
-    host &&= host
+    host && (host = host
         .replace(/^[*][.]/, '([^/]+.)*') // Initial wildcard
         .replaceAll(/[.]/g, '[.]') // Escape dots
-        .replace(/[*]$/, '[^.]+'); // Last wildcard
+        .replace(/[*]$/, '[^.]+')); // Last wildcard
     pathname = pathname
         .replaceAll(/[/]/g, '[/]') // Escape slashes
         .replaceAll(/[.]/g, '[.]') // Escape dots
         .replaceAll(/[*]/g, '.*'); // Any wildcard
     return '^' + protocol + host + '(' + pathname + ')?$';
 }
-export function patternToRegex(...matchPatterns) {
+function patternToRegex() {
+    var matchPatterns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        matchPatterns[_i] = arguments[_i];
+    }
     // No pattern, match nothing https://stackoverflow.com/q/14115522/288906
     if (matchPatterns.length === 0) {
         return /$./;
     }
     if (matchPatterns.includes('<all_urls>')) {
-        return allUrlsRegex;
+        return exports.allUrlsRegex;
     }
     if (matchPatterns.includes('*://*/*')) {
-        return allStarsRegex;
+        return exports.allStarsRegex;
     }
-    return new RegExp(matchPatterns.map(x => getRawPatternRegex(x)).join('|'));
+    return new RegExp(matchPatterns.map(function (x) { return getRawPatternRegex(x); }).join('|'));
 }
+exports.patternToRegex = patternToRegex;
 // The parens are required by .split() to preserve the symbols
-const globSymbols = /([?*]+)/;
+var globSymbols = /([?*]+)/;
 function splitReplace(part, index) {
     if (part === '') {
         // Shortcut for speed
@@ -73,16 +95,17 @@ function splitReplace(part, index) {
     }
     if (index % 2 === 0) {
         // Raw text, escape it
-        return escapeStringRegexp(part);
+        // eslint-disable-next-line no-use-extend-native/no-use-extend-native -- TODO: Drop after https://github.com/dustinspecker/eslint-plugin-no-use-extend-native/issues/157
+        return RegExp.escape(part);
     }
     // Else: Symbol
     if (part.includes('*')) { // Can be more than one and it swallows surrounding question marks
         return '.*';
     }
-    return [...part].map(() => isFirefox ? '.' : '.?').join('');
+    return __spreadArray([], part, true).map(function () { return isFirefox ? '.' : '.?'; }).join('');
 }
 function getRawGlobRegex(glob) {
-    const regexString = glob
+    var regexString = glob
         .split(globSymbols)
         // eslint-disable-next-line unicorn/no-array-callback-reference -- tis ok 🤫
         .map(splitReplace)
@@ -93,14 +116,19 @@ function getRawGlobRegex(glob) {
         .replace(/[.][*]$/, '')
         .replace(/^[$]$/, '.+'); // Catch `*` and `*`
 }
-export function globToRegex(...globs) {
+function globToRegex() {
+    var globs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        globs[_i] = arguments[_i];
+    }
     // No glob, match anything; `include_globs: []` is the default
     if (globs.length === 0) {
         return /.*/;
     }
-    return new RegExp(globs.map(x => getRawGlobRegex(x)).join('|'));
+    return new RegExp(globs.map(function (x) { return getRawGlobRegex(x); }).join('|'));
 }
-export function excludeDuplicatePatterns(matchPatterns) {
+exports.globToRegex = globToRegex;
+function removeRedundantPatterns(matchPatterns) {
     if (matchPatterns.includes('<all_urls>')) {
         return ['<all_urls>'];
     }
@@ -108,12 +136,15 @@ export function excludeDuplicatePatterns(matchPatterns) {
         return ['*://*/*'];
     }
     // Cover identical patterns
-    const uniquePatterns = [...new Set(matchPatterns)];
-    return uniquePatterns.filter(possibleSubset => 
-    // Keep if there are no matches
-    !uniquePatterns.some(possibleSuperset => 
-    // Don't compare to self
-    possibleSubset !== possibleSuperset
-        // Drop if it's a subset
-        && patternToRegex(possibleSuperset).test(possibleSubset)));
+    var uniquePatterns = __spreadArray([], new Set(matchPatterns), true);
+    return uniquePatterns.filter(function (possibleSubset) {
+        // Keep if there are no matches
+        return !uniquePatterns.some(function (possibleSuperset) {
+            // Don't compare to self
+            return possibleSubset !== possibleSuperset
+                // Drop if it's a subset
+                && patternToRegex(possibleSuperset).test(possibleSubset);
+        });
+    });
 }
+exports.removeRedundantPatterns = removeRedundantPatterns;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "webext-patterns",
-	"version": "1.5.1",
+	"version": "2.0.0",
 	"description": "Tool to convert the patterns and globs of your WebExtension manifest to regex",
 	"keywords": [
 		"browser",
@@ -32,32 +32,21 @@
 		"fix": "xo --fix",
 		"lint": "xo",
 		"prepare": "tsc --sourceMap false",
-		"test": "tsc && ava && xo",
+		"test": "tsc && vitest run && xo",
 		"watch": "tsc --watch"
 	},
-	"xo": {
-		"envs": [
-			"browser",
-			"webextensions"
-		],
-		"rules": {
-			"unicorn/better-regex": "off"
-		}
-	},
-	"dependencies": {
-		"escape-string-regexp": "^5.0.0"
-	},
 	"devDependencies": {
-		"@sindresorhus/tsconfig": "^5.0.0",
-		"@types/chrome": "0.0.268",
-		"ava": "^6.1.3",
-		"sinon": "^18.0.0",
-		"type-fest": "^4.20.0",
-		"typescript": "^5.4.5",
-		"xo": "^0.58.0"
+		"@sindresorhus/tsconfig": "^8.1.0",
+		"@types/chrome": "^0.1.39",
+		"globals": "^17.4.0",
+		"sinon": "^21.0.3",
+		"type-fest": "^5.5.0",
+		"typescript": "^6.0.2",
+		"vitest": "^4.1.2",
+		"xo": "^2.0.2"
 	},
 	"engines": {
-		"node": ">=18"
+		"node": ">=24"
 	},
 	"webExt": {
 		"sourceDir": "demo-extension",

package/readme.md

@@ -1,10 +1,9 @@
-# webext-patterns [![][badge-gzip]][link-bundlephobia]
-
-[badge-gzip]: https://img.shields.io/bundlephobia/minzip/webext-patterns.svg?label=gzipped
-[link-bundlephobia]: https://bundlephobia.com/result?p=webext-patterns
+# webext-patterns 
 
 > Utilities for [patterns](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/content_scripts#matching_url_patterns) and globs for WebExtensions
 
+**Sponsored by [PixieBrix](https://www.pixiebrix.com)** :tada:
+
 ## Install
 
 You can download the [standalone bundle](https://bundle.fregante.com/?pkg=webext-patterns) and include it in your `manifest.json`.
@@ -19,8 +18,8 @@ npm install webext-patterns
 import {
 	patternToRegex,
 	globToRegex,
-	excludeDuplicatePatterns
-	doesUrlMatchPatterns,
+	removeRedundantPatterns,
+	testPatterns,
 	assertValidPattern,
 	isValidPattern,
 } from 'webext-patterns';
@@ -35,7 +34,7 @@ patternToRegex('http://*/*');
 globToRegex('*.example.com');
 // Returns /\.example\.com$/
 
-excludeDuplicatePatterns(['https://*.google.com/*', 'https://google.com/*']);
+removeRedundantPatterns(['https://*.google.com/*', 'https://google.com/*']);
 // Returns ['https://*.google.com/*']
 
 assertValidPattern('https://google.*/*');
@@ -48,6 +47,9 @@ isValidPattern('https://*.google.com/*');
 > **Note**
 > Firefox and Chrome handle patterns very slighly differently. `webext-patterns` defaults to Chrome’s logic, but if it detects a Firefox userAgent it will produce a Firefox-compatible regex.
 
+> **Note**
+> This package uses `RegExp.escape`, which requires browsers from May 2025 and later.
+
 ## API
 
 #### patternToRegex(pattern1, pattern2, etc)
@@ -97,12 +99,12 @@ googleRegex.test('https://google.it/search'); // -> true
 googleRegex.test('https://google.de/search'); // -> false
 ```
 
-#### excludeDuplicatePatterns([pattern1, pattern2, etc])
+#### removeRedundantPatterns([pattern1, pattern2, etc])
 
 Accepts an array of patterns and returns a filtered array without the patterns that are already covered by others. For example `"https://*/*"` already covers all "https" URLs, so having `"https://google.com/*"` in the array won't make any difference and therefore it's dropped.
 
 ```js
-excludeDuplicatePatterns([
+removeRedundantPatterns([
 	"https://*/*",
 	"https://google.com/*",
 	"https://*.example.com/*",
@@ -110,18 +112,18 @@ excludeDuplicatePatterns([
 // Returns ["https://*/*"]
 ```
 
-#### doesUrlMatchPatterns(url, ...patterns)
+#### testPatterns(url, patterns)
 
-Accepts a URL and any number of patterns and returns `true` if the URL matches any of the patterns. This is a convenience method that wraps `patternToRegex` for single use. If you plan on testing multiple URLs to the same pattern, it's better to convert the patterns to a regex once and reuse that.
+Accepts a URL and an array of patterns and returns `true` if the URL matches any of the patterns. This is a convenience method that wraps `patternToRegex` for single use. If you plan on testing multiple URLs against the same patterns, it's better to convert the patterns to a regex once and reuse that.
 
 ```js
-doesUrlMatchPatterns('https://google.com/', 'https://*.google.com/*', '*://example.com/*');
+testPatterns('https://google.com/', ['https://*.google.com/*', '*://example.com/*']);
 // Returns true
 ```
 
-#### findMatchingPatterns(url, ...patterns)
+#### getMatchingPatterns(url, patterns)
 
-Accepts a URL and any number of patterns and returns an array of the patterns that match the URL. It returns an empty array if none of the patterns match the URL.
+Accepts a URL and an array of patterns and returns an array of the patterns that match the URL. It returns an empty array if none of the patterns match the URL.
 
 #### assertValidPattern(pattern)