glob-to-regex.js 1.1.0 → 1.2.0

package/README.md

@@ -46,6 +46,13 @@ match('types.d.ts');  // true (negation is not parsed specially)
 - `**` matches across path segments, including none
 - `{a,b,c}` alternation groups (no nesting). Each item inside can itself contain glob syntax
 - Character classes: `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]`
+- **Extended globbing** (when `extglob: true` option is set):
+  - `?(pattern-list)` matches zero or one occurrence of the given patterns
+  - `*(pattern-list)` matches zero or more occurrences of the given patterns
+  - `+(pattern-list)` matches one or more occurrences of the given patterns
+  - `@(pattern-list)` matches exactly one of the given patterns
+  - `!(pattern-list)` matches anything except one of the given patterns
+  - Pattern lists use `|` as separator (e.g., `@(jpg|png|gif)`)
 
 Notes:
 - The produced RegExp is anchored at start and end (`^...$`).
@@ -66,6 +73,15 @@ toRegex('src/{a,b}/**/*.ts').test('src/b/x/y.ts'); // true
 toRegex('file[0-9].txt').test('file5.txt');        // true
 toRegex('file[!0-9].txt').test('filea.txt');       // true
 toRegex('**/*.[jt]s{,x}').test('dir/a/b.jsx');     // true
+
+// Extended globbing examples
+toRegex('file?(s).txt', {extglob: true}).test('file.txt');  // true
+toRegex('file?(s).txt', {extglob: true}).test('files.txt'); // true
+toRegex('file.@(jpg|png|gif)', {extglob: true}).test('file.jpg'); // true
+toRegex('/var/log/!(*.gz)', {extglob: true}).test('/var/log/syslog'); // true
+toRegex('/var/log/!(*.gz)', {extglob: true}).test('/var/log/error.log.gz'); // false
+toRegex('src/**/!(*.test).js', {extglob: true}).test('src/app.test.js'); // false
+toRegex('src/**/!(*.test).js', {extglob: true}).test('src/index.js'); // true
 ```
 
 ## TypeScript

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 export interface GlobOptions {
     /** Treat pattern as case insensitive */
     nocase?: boolean;
+    /** Enable extended globbing: ?(pattern), *(pattern), +(pattern), @(pattern), !(pattern) */
+    extglob?: boolean;
 }
 /**
  * Convert a glob pattern to a regular expression
@@ -12,6 +14,12 @@ export interface GlobOptions {
  * - `**` to match any number of path segments, including none
  * - `{}` to group conditions (e.g. `{html,txt}`)
  * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]` character classes
+ * - Extended globbing (when `extglob: true` option is set):
+ *   - `?(pattern-list)` zero or one occurrence
+ *   - `*(pattern-list)` zero or more occurrences
+ *   - `+(pattern-list)` one or more occurrences
+ *   - `@(pattern-list)` exactly one of the patterns
+ *   - `!(pattern-list)` anything except the patterns
  */
 export declare const toRegex: (pattern: string, options?: GlobOptions) => RegExp;
 /**

package/lib/index.js

@@ -2,6 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toMatcher = exports.toRegex = void 0;
 const escapeRe = (ch) => (/[.^$+{}()|\\]/.test(ch) ? `\\${ch}` : ch);
+/**
+ * Parse an extended glob pattern like ?(a|b|c)
+ * Returns the regex string equivalent and the new index position
+ */
+const parseExtGlob = (pattern, startIdx, prefix, options) => {
+    let i = startIdx; // startIdx should be pointing at the character after '('
+    const parts = [];
+    let cur = '';
+    let depth = 1; // Track parenthesis depth for nested patterns
+    while (i < pattern.length && depth > 0) {
+        const ch = pattern[i];
+        if (ch === '(') {
+            depth++;
+            cur += ch;
+            i++;
+        }
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0) {
+                // Found the closing parenthesis
+                parts.push(cur);
+                i++; // consume ')'
+                break;
+            }
+            else {
+                cur += ch;
+                i++;
+            }
+        }
+        else if (ch === '|' && depth === 1) {
+            // Pipe separator at top level of this extglob
+            parts.push(cur);
+            cur = '';
+            i++;
+        }
+        else {
+            cur += ch;
+            i++;
+        }
+    }
+    if (depth !== 0)
+        return; // Unclosed parenthesis
+    let alternatives = '';
+    const length = parts.length;
+    for (let j = 0; j < length; j++)
+        alternatives += (alternatives ? '|' : '') + (0, exports.toRegex)(parts[j], options).source.replace(/^\^/, '').replace(/\$$/, '');
+    switch (prefix) {
+        case '?': // zero or one
+            return [`(?:${alternatives})?`, i];
+        case '*': // zero or more
+            return [`(?:${alternatives})*`, i];
+        case '+': // one or more
+            return [`(?:${alternatives})+`, i];
+        case '@': // exactly one
+            return [`(?:${alternatives})`, i];
+        case '!': // none of (negative match)
+            // For negation, we need to match anything that doesn't match the pattern
+            // Use negative lookahead without consuming characters after
+            return [`(?!${alternatives})[^/]*`, i];
+    }
+    return;
+};
 /**
  * Convert a glob pattern to a regular expression
  *
@@ -12,6 +74,12 @@ const escapeRe = (ch) => (/[.^$+{}()|\\]/.test(ch) ? `\\${ch}` : ch);
  * - `**` to match any number of path segments, including none
  * - `{}` to group conditions (e.g. `{html,txt}`)
  * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]` character classes
+ * - Extended globbing (when `extglob: true` option is set):
+ *   - `?(pattern-list)` zero or one occurrence
+ *   - `*(pattern-list)` zero or more occurrences
+ *   - `+(pattern-list)` one or more occurrences
+ *   - `@(pattern-list)` exactly one of the patterns
+ *   - `!(pattern-list)` anything except the patterns
  */
 const toRegex = (pattern, options) => {
     let regexStr = '';
@@ -48,8 +116,21 @@ const toRegex = (pattern, options) => {
         const alt = parts.map((p) => (0, exports.toRegex)(p, options).source.replace(/^\^/, '').replace(/\$$/, '')).join('|');
         return `(?:${alt})`;
     };
+    const extglob = !!options?.extglob;
     while (i < pattern.length) {
         const char = pattern[i];
+        // Check for extended glob patterns when extglob is enabled
+        if (extglob && pattern[i + 1] === '(') {
+            if (char === '?' || char === '*' || char === '+' || char === '@' || char === '!') {
+                const result = parseExtGlob(pattern, i + 2, char, options);
+                if (result) {
+                    regexStr += result[0];
+                    i = result[1];
+                    continue;
+                }
+                // If parse failed, fall through to normal handling
+            }
+        }
         switch (char) {
             case '*': {
                 // Check for double star **

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Transform GLOB patterns to JavaScript regular expressions for fast file path matching.",
   "author": {
     "name": "streamich",