glob-to-regex.js 1.2.0 → 1.3.0

package/README.md

@@ -2,7 +2,8 @@
 
 Transform GLOB patterns to JavaScript regular expressions for fast file path matching.
 
-This tiny library converts familiar shell-style glob patterns like `**/*.ts` or `src/{a,b}/**/*.js` into JavaScript `RegExp` objects and provides a convenient matcher utility.
+This tiny library converts familiar shell-style glob patterns like `**/*.ts` or `src/{a,b}/**/*.js` into JavaScript `RegExp` objects and provides a convenient matcher utility. Matching semantics follow `minimatch`,
+so the regexes can stand in for it segment by segment.
 
 ## Install
 
@@ -15,7 +16,7 @@ npm i glob-to-regex.js
 ## Quick start
 
 ```ts
-import {toRegex, toMatcher} from 'glob-to-regex.js';
+import {toRegex, toMatcher, expandBraces} from 'glob-to-regex.js';
 
 // Build a RegExp from a glob
 const re = toRegex('src/**/test.ts');
@@ -23,41 +24,61 @@ re.test('src/a/b/test.ts'); // true
 re.test('src/test.ts');     // true
 re.test('src/test.tsx');    // false
 
+// Shell rules for dotfiles and extended globs
+const shell = toRegex('**/!(*.test).js', {dot: false, extglob: true});
+shell.test('src/index.js');    // true
+shell.test('src/app.test.js'); // false
+shell.test('.git/hooks.js');   // false
+
 // Build a predicate function from a pattern or an array of patterns
-const match = toMatcher(['**/*.ts', '!**/*.d.ts']); // negative patterns are not special; use a RegExp if needed
-match('index.ts');    // true
-match('types.d.ts');  // true (negation is not parsed specially)
+const match = toMatcher(['**/*.ts', '/\\.d\\.ts$/']);
+match('index.ts');   // true
+match('types.d.ts'); // true
+
+expandBraces('src/{lib,test}/{1..3}.ts');
+// ['src/lib/1.ts', 'src/lib/2.ts', ..., 'src/test/3.ts']
 ```
 
 ## API
 
-- toRegex(pattern: string): RegExp
+- `toRegex(pattern: string, options?: GlobOptions): RegExp`
 	- Converts a glob pattern to an anchored regular expression (`^...$`).
 
-- toMatcher(pattern: string | RegExp | Array<string | RegExp>): (path: string) => boolean
+- `toMatcher(pattern: string | RegExp | Array<string | RegExp>, options?: GlobOptions): (path: string) => boolean`
 	- Accepts a glob string, a RegExp, or an array of them. If given an array, it returns true if any item matches (logical OR, short-circuited).
 	- Strings starting with `/` and ending with `/flags?` are treated as regular expressions (e.g. `"/\\.test\\.ts$/"`).
 
+- `expandBraces(pattern: string, max?: number): string[]`
+	- Expands `{a,b}` alternations and `{1..3}` ranges into the list of patterns they stand for, nesting included. Stops after `max` patterns (default 100,000).
+
+### Options
+
+- `nocase` — case-insensitive matching.
+- `extglob` — enables the `?(...)`, `*(...)`, `+(...)`, `@(...)` and `!(...)` groups.
+- `dot` — whether `*`, `?`, `[...]` and extglobs match a leading `.` of a path segment. Defaults to `true`; `false` is the shell rule, where a dotfile is matched only by a literal dot in the pattern (`.*` matches `.gitignore`, `*` does not) and `**` does not descend into dot directories.
+
 ## Supported glob features
 
 - `/` separates path segments
-- `*` matches zero or more characters within a single segment (does not cross `/`)
+- `*` matches zero or more characters within a single segment (does not cross `/`). A segment that is only `*` matches at least one character, as a file name is never empty: `a/*` does not match `a/`
 - `?` matches exactly one character within a single segment
-- `**` 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]`
+- `**` matches across path segments, including none. `**/**/` is the same as `**/`
+- `{a,b,c}` alternation groups, nested as in `{a,{b,c}}`. Each item can itself contain glob syntax
+- `{1..3}`, `{a..c}`, `{01..10..2}` ranges, with the step and zero padding of bash
+- Character classes: `[abc]`, `[a-z]`, `[!a-z]`, `[^a-z]`, and POSIX classes such as `[[:alpha:]]` or `[a[:digit:]]`. A `]` right after the opening bracket is a member of the class: `[]a]` matches `]` or `a`
 - **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-list)` matches anything except one of the given patterns. The exclusion covers the rest of the pattern, so `!(a).js` rejects `a.js` and accepts `ab.js`; `!()` matches any non-empty segment
   - Pattern lists use `|` as separator (e.g., `@(jpg|png|gif)`)
 
 Notes:
 - The produced RegExp is anchored at start and end (`^...$`).
-- Character classes are copied through to the output regex. Use standard JavaScript class syntax.
-- Brace groups are not nestable. If an unmatched `{` is found, it is treated literally.
+- A brace group without a comma or range (`{a}`, `{}`) and an unmatched `{`, `[` or `(` are literal.
+- A range with its ends reversed, like `[z-a]`, matches nothing instead of throwing.
+- There is no escape character: a backslash is a literal backslash.
 
 ## Examples
 
@@ -70,10 +91,18 @@ toRegex('src/**/test.ts').test('src/a/b/test.ts'); // true
 toRegex('assets/**').test('assets/a/b.png');       // true
 toRegex('*.{html,txt}').test('page.html');         // true
 toRegex('src/{a,b}/**/*.ts').test('src/b/x/y.ts'); // true
+toRegex('v{1..3}.tgz').test('v2.tgz');             // true
 toRegex('file[0-9].txt').test('file5.txt');        // true
 toRegex('file[!0-9].txt').test('filea.txt');       // true
+toRegex('[[:upper:]]*.ts').test('App.ts');         // true
 toRegex('**/*.[jt]s{,x}').test('dir/a/b.jsx');     // true
 
+// Dotfiles
+toRegex('*.js').test('.eslintrc.js');               // true
+toRegex('*.js', {dot: false}).test('.eslintrc.js'); // false
+toRegex('.*', {dot: false}).test('.eslintrc.js');   // true
+toRegex('**/*.js', {dot: false}).test('node_modules/.cache/a.js'); // false
+
 // Extended globbing examples
 toRegex('file?(s).txt', {extglob: true}).test('file.txt');  // true
 toRegex('file?(s).txt', {extglob: true}).test('files.txt'); // true
@@ -82,6 +111,8 @@ 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
+toRegex('!(a).js', {extglob: true}).test('ab.js'); // true
+toRegex('!(a).js', {extglob: true}).test('a.js');  // false
 ```
 
 ## TypeScript
@@ -94,10 +125,10 @@ Types are bundled. The library targets modern Node.js and browsers.
 
 ## Limitations
 
-- Brace groups are not nested.
 - Negated globs like `!**/*.d.ts` are not parsed specially. If you need exclusion, combine multiple matchers or filter results separately.
+- `**` is a globstar wherever it appears, not only as a whole segment: `a**` matches across `/`.
+- Like minimatch, `!(a)*` does not match `a`: the negation rejects the whole remainder, while bash tries every split.
 
 ## License
 
 Apache-2.0 © streamich
-

package/lib/index.d.ts

@@ -3,7 +3,17 @@ export interface GlobOptions {
     nocase?: boolean;
     /** Enable extended globbing: ?(pattern), *(pattern), +(pattern), @(pattern), !(pattern) */
     extglob?: boolean;
+    /** Whether `*`, `?`, `[...]` and extglobs match a leading `.` of a path segment. */
+    dot?: boolean;
 }
+/**
+ * Expands `{a,b}` alternations and `{1..3}`, `{a..c}`, `{01..10..2}` ranges the
+ * way bash does, nesting included. A group with neither a comma nor a range,
+ * or without its closing brace, is kept as it is.
+ *
+ * @param max Number of expansions to stop at, as `brace-expansion` does.
+ */
+export declare const expandBraces: (pattern: string, max?: number) => string[];
 /**
  * Convert a glob pattern to a regular expression
  *
@@ -12,8 +22,8 @@ export interface GlobOptions {
  * - `*` to match zero or more characters in a path segment
  * - `?` to match one character in a path segment
  * - `**` to match any number of path segments, including none
- * - `{}` to group conditions (e.g. `{html,txt}`)
- * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]` character classes
+ * - `{}` to group conditions (e.g. `{html,txt}`), nested, and `{1..3}` ranges
+ * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]`, `[[:alpha:]]` character classes
  * - Extended globbing (when `extglob: true` option is set):
  *   - `?(pattern-list)` zero or one occurrence
  *   - `*(pattern-list)` zero or more occurrences

package/lib/index.js

@@ -1,69 +1,385 @@
 "use strict";
 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 === '(') {
+exports.toMatcher = exports.toRegex = exports.expandBraces = void 0;
+const NODOT = '(?!\\.)';
+const STAR = '[^/]*';
+const GLOBSTAR_NODOT = '[^/]*(?:/(?!\\.)[^/]*)*';
+const literal = (pattern, i, code) => {
+    switch (code) {
+        case 36 /* Code.Dollar */:
+        case 40 /* Code.LParen */:
+        case 41 /* Code.RParen */:
+        case 43 /* Code.Plus */:
+        case 46 /* Code.Dot */:
+        case 92 /* Code.Backslash */:
+        case 93 /* Code.RBracket */:
+        case 94 /* Code.Caret */:
+        case 123 /* Code.LBrace */:
+        case 124 /* Code.Pipe */:
+        case 125 /* Code.RBrace */:
+            return '\\' + pattern[i];
+        default:
+            return pattern[i];
+    }
+};
+const posixClass = (name) => {
+    switch (name) {
+        case 'alnum':
+            return '0-9A-Za-z';
+        case 'alpha':
+            return 'A-Za-z';
+        case 'ascii':
+            return '\\x00-\\x7f';
+        case 'blank':
+            return ' \\t';
+        case 'cntrl':
+            return '\\x00-\\x1f\\x7f';
+        case 'digit':
+            return '0-9';
+        case 'graph':
+            return '\\x21-\\x7e';
+        case 'lower':
+            return 'a-z';
+        case 'print':
+            return '\\x20-\\x7e';
+        case 'punct':
+            return '\\x21-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7e';
+        case 'space':
+            return ' \\t\\r\\n\\v\\f';
+        case 'upper':
+            return 'A-Z';
+        case 'word':
+            return '0-9A-Za-z_';
+        case 'xdigit':
+            return '0-9A-Fa-f';
+    }
+    return;
+};
+const classEnd = (pattern, i) => {
+    const length = pattern.length;
+    let j = i + 1;
+    const first = pattern.charCodeAt(j);
+    if (first === 33 /* Code.Bang */ || first === 94 /* Code.Caret */)
+        j++;
+    if (pattern.charCodeAt(j) === 93 /* Code.RBracket */)
+        j++;
+    for (; j < length; j++) {
+        const code = pattern.charCodeAt(j);
+        if (code === 93 /* Code.RBracket */)
+            return j + 1;
+        if (code === 91 /* Code.LBracket */ && pattern.charCodeAt(j + 1) === 58 /* Code.Colon */) {
+            const close = pattern.indexOf(':]', j + 2);
+            if (close > 0)
+                j = close + 1;
+        }
+    }
+    return -1;
+};
+const member = (pattern, i) => {
+    const code = pattern.charCodeAt(i);
+    const special = code === 93 /* Code.RBracket */ ||
+        code === 92 /* Code.Backslash */ ||
+        code === 91 /* Code.LBracket */ ||
+        code === 94 /* Code.Caret */ ||
+        code === 45 /* Code.Minus */;
+    return (special ? '\\' : '') + pattern[i];
+};
+const classSource = (pattern, i, end) => {
+    const last = end - 1;
+    let j = i + 1;
+    let out = '';
+    let members = 0;
+    const first = pattern.charCodeAt(j);
+    const negate = first === 33 /* Code.Bang */ || first === 94 /* Code.Caret */;
+    if (negate)
+        j++;
+    while (j < last) {
+        if (pattern.charCodeAt(j) === 91 /* Code.LBracket */ && pattern.charCodeAt(j + 1) === 58 /* Code.Colon */) {
+            const close = pattern.indexOf(':]', j + 2);
+            const cls = close > 0 ? posixClass(pattern.slice(j + 2, close)) : undefined;
+            if (cls !== undefined) {
+                out += cls;
+                members += 2;
+                j = close + 2;
+                continue;
+            }
+        }
+        if (pattern.charCodeAt(j + 1) === 45 /* Code.Minus */ && j + 2 < last) {
+            if (pattern.charCodeAt(j + 2) >= pattern.charCodeAt(j)) {
+                out += member(pattern, j) + '-' + member(pattern, j + 2);
+                members += 2;
+            }
+            j += 3;
+            continue;
+        }
+        out += member(pattern, j);
+        members++;
+        j++;
+    }
+    if (!negate && members === 1)
+        return literal(pattern, last - 1, pattern.charCodeAt(last - 1));
+    if (!members)
+        return negate ? '[^/]' : '[]';
+    return (negate ? '[^' : '[') + out + ']';
+};
+const groupEnd = (pattern, i) => {
+    const length = pattern.length;
+    let depth = 1;
+    for (; i < length; i++) {
+        const code = pattern.charCodeAt(i);
+        if (code === 91 /* Code.LBracket */) {
+            const end = classEnd(pattern, i);
+            if (end > 0)
+                i = end - 1;
+        }
+        else if (code === 40 /* Code.LParen */)
             depth++;
-            cur += ch;
-            i++;
+        else if (code === 41 /* Code.RParen */ && !--depth)
+            return i + 1;
+    }
+    return -1;
+};
+const splitAlts = (body) => {
+    const length = body.length;
+    const alts = [];
+    let depth = 0;
+    let from = 0;
+    for (let i = 0; i < length; i++) {
+        const code = body.charCodeAt(i);
+        if (code === 91 /* Code.LBracket */) {
+            const end = classEnd(body, i);
+            if (end > 0)
+                i = end - 1;
         }
-        else if (ch === ')') {
+        else if (code === 40 /* Code.LParen */)
+            depth++;
+        else if (code === 41 /* Code.RParen */)
             depth--;
-            if (depth === 0) {
-                // Found the closing parenthesis
-                parts.push(cur);
-                i++; // consume ')'
+        else if (code === 124 /* Code.Pipe */ && !depth) {
+            alts.push(body.slice(from, i));
+            from = i + 1;
+        }
+    }
+    alts.push(body.slice(from));
+    return alts;
+};
+const isExtglobPrefix = (code) => code === 63 /* Code.Qmark */ || code === 42 /* Code.Star */ || code === 43 /* Code.Plus */ || code === 64 /* Code.At */ || code === 33 /* Code.Bang */;
+const altsSource = (alts, extglob, nodot, tail, segStart) => {
+    let out = '';
+    for (let i = 0; i < alts.length; i++)
+        out += (i ? '|' : '') + compile(alts[i], extglob, nodot, tail, segStart);
+    return out;
+};
+const extglobSource = (type, alts, extglob, nodot, tail, segStart) => {
+    const guard = nodot && segStart ? NODOT : '';
+    const body = altsSource(alts, extglob, nodot, tail, segStart);
+    switch (type) {
+        case 63 /* Code.Qmark */:
+            return '(?:' + body + ')?';
+        case 64 /* Code.At */:
+            return '(?:' + body + ')';
+        case 33 /* Code.Bang */:
+            if (alts.length === 1 && !alts[0])
+                return guard + '[^/]+';
+            return '(?!(?:' + body + ')' + tail + '$)' + guard + STAR;
+    }
+    const more = guard ? altsSource(alts, extglob, nodot, tail, false) : body;
+    if (more === body)
+        return '(?:' + body + ')' + (type === 42 /* Code.Star */ ? '*' : '+');
+    const once = '(?:' + body + ')(?:' + more + ')*';
+    return type === 42 /* Code.Star */ ? '(?:' + once + ')?' : once;
+};
+const compile = (pattern, extglob, nodot, tail, segStart) => {
+    const length = pattern.length;
+    let out = '';
+    let i = 0;
+    let start = segStart;
+    while (i < length) {
+        const code = pattern.charCodeAt(i);
+        if (extglob && pattern.charCodeAt(i + 1) === 40 /* Code.LParen */ && isExtglobPrefix(code)) {
+            const end = groupEnd(pattern, i + 2);
+            if (end > 0) {
+                const after = compile(pattern.slice(end), extglob, nodot, tail, false);
+                const alts = splitAlts(pattern.slice(i + 2, end - 1));
+                return out + extglobSource(code, alts, extglob, nodot, after + tail, start) + after;
+            }
+        }
+        const atStart = start;
+        const guard = nodot && atStart ? NODOT : '';
+        start = false;
+        switch (code) {
+            case 42 /* Code.Star */: {
+                let j = i + 1;
+                while (pattern.charCodeAt(j) === 42 /* Code.Star */)
+                    j++;
+                if (j === i + 1) {
+                    // a whole segment of `*` needs a character: a file name is never empty
+                    const whole = atStart && (j === length || pattern.charCodeAt(j) === 47 /* Code.Slash */);
+                    out += guard + (whole ? '[^/]+' : STAR);
+                    i = j;
+                    break;
+                }
+                // `**/**/` is `**/`, and `**/**` is `**`: a second globstar only multiplies the backtracking
+                let slash = pattern.charCodeAt(j) === 47 /* Code.Slash */;
+                while (slash) {
+                    let k = j + 1;
+                    if (pattern.charCodeAt(k) !== 42 /* Code.Star */ || pattern.charCodeAt(k + 1) !== 42 /* Code.Star */)
+                        break;
+                    k += 2;
+                    while (pattern.charCodeAt(k) === 42 /* Code.Star */)
+                        k++;
+                    if (k === length) {
+                        j = k;
+                        slash = false;
+                    }
+                    else if (pattern.charCodeAt(k) === 47 /* Code.Slash */)
+                        j = k;
+                    else
+                        break;
+                }
+                if (slash) {
+                    out += nodot ? '(?:' + guard + GLOBSTAR_NODOT + '/)?' : '(?:.*/)?';
+                    j++;
+                    start = true;
+                }
+                else
+                    out += nodot ? guard + GLOBSTAR_NODOT : '.*';
+                i = j;
                 break;
             }
-            else {
-                cur += ch;
+            case 63 /* Code.Qmark */:
+                out += guard + '[^/]';
                 i++;
+                break;
+            case 91 /* Code.LBracket */: {
+                const end = classEnd(pattern, i);
+                if (end < 0) {
+                    out += '\\[';
+                    i++;
+                    break;
+                }
+                const cls = classSource(pattern, i, end);
+                out += (cls.charCodeAt(0) === 91 /* Code.LBracket */ ? guard : '') + cls;
+                i = end;
+                break;
             }
+            case 47 /* Code.Slash */:
+                out += '/';
+                i++;
+                start = true;
+                break;
+            default:
+                out += literal(pattern, i, code);
+                i++;
         }
-        else if (ch === '|' && depth === 1) {
-            // Pipe separator at top level of this extglob
-            parts.push(cur);
-            cur = '';
-            i++;
+    }
+    return out;
+};
+const closingBrace = (pattern, open) => {
+    const length = pattern.length;
+    let depth = 0;
+    for (let i = open; i < length; i++) {
+        const code = pattern.charCodeAt(i);
+        if (code === 123 /* Code.LBrace */)
+            depth++;
+        else if (code === 125 /* Code.RBrace */ && !--depth)
+            return i;
+    }
+    return -1;
+};
+const commaSplit = (body) => {
+    const length = body.length;
+    const parts = [];
+    let depth = 0;
+    let from = 0;
+    for (let i = 0; i < length; i++) {
+        const code = body.charCodeAt(i);
+        if (code === 123 /* Code.LBrace */)
+            depth++;
+        else if (code === 125 /* Code.RBrace */)
+            depth--;
+        else if (code === 44 /* Code.Comma */ && !depth) {
+            parts.push(body.slice(from, i));
+            from = i + 1;
         }
-        else {
-            cur += ch;
-            i++;
+    }
+    if (!parts.length)
+        return;
+    parts.push(body.slice(from));
+    return parts;
+};
+const NUMERIC_RANGE = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+const ALPHA_RANGE = /^([a-zA-Z])\.\.([a-zA-Z])(?:\.\.(-?\d+))?$/;
+const PADDED = /^-?0\d/;
+const rangeOf = (body, max) => {
+    let match = NUMERIC_RANGE.exec(body);
+    const alpha = !match;
+    if (alpha)
+        match = ALPHA_RANGE.exec(body);
+    if (!match)
+        return;
+    const from = alpha ? match[1].charCodeAt(0) : +match[1];
+    const to = alpha ? match[2].charCodeAt(0) : +match[2];
+    const step = match[3] === undefined ? 1 : Math.abs(+match[3]) || 1;
+    const width = !alpha && (PADDED.test(match[1]) || PADDED.test(match[2])) ? Math.max(match[1].length, match[2].length) : 0;
+    const out = [];
+    const dir = from <= to ? step : -step;
+    for (let n = from; (dir > 0 ? n <= to : n >= to) && out.length < max; n += dir) {
+        if (alpha) {
+            out.push(String.fromCharCode(n));
+            continue;
         }
+        let s = String(n);
+        const need = width - s.length;
+        if (need > 0) {
+            let zeros = '';
+            for (let k = 0; k < need; k++)
+                zeros += '0';
+            s = n < 0 ? '-' + zeros + s.slice(1) : zeros + s;
+        }
+        out.push(s);
     }
-    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 out;
+};
+const expandInto = (pattern, out, max) => {
+    for (let open = pattern.indexOf('{'); open >= 0; open = pattern.indexOf('{', open + 1)) {
+        const close = closingBrace(pattern, open);
+        if (close < 0)
+            continue;
+        const body = pattern.slice(open + 1, close);
+        const alts = commaSplit(body) || rangeOf(body, max);
+        if (!alts)
+            continue;
+        const prefix = pattern.slice(0, open);
+        const suffixes = (0, exports.expandBraces)(pattern.slice(close + 1), max);
+        for (let i = 0; i < alts.length; i++) {
+            const heads = (0, exports.expandBraces)(alts[i], max);
+            for (let j = 0; j < heads.length; j++) {
+                const head = prefix + heads[j];
+                for (let k = 0; k < suffixes.length; k++) {
+                    if (out.length >= max)
+                        return;
+                    out.push(head + suffixes[k]);
+                }
+            }
+        }
+        return;
     }
-    return;
+    out.push(pattern);
 };
+/**
+ * Expands `{a,b}` alternations and `{1..3}`, `{a..c}`, `{01..10..2}` ranges the
+ * way bash does, nesting included. A group with neither a comma nor a range,
+ * or without its closing brace, is kept as it is.
+ *
+ * @param max Number of expansions to stop at, as `brace-expansion` does.
+ */
+const expandBraces = (pattern, max = 100000) => {
+    const out = [];
+    expandInto(pattern, out, max);
+    return out;
+};
+exports.expandBraces = expandBraces;
 /**
  * Convert a glob pattern to a regular expression
  *
@@ -72,8 +388,8 @@ const parseExtGlob = (pattern, startIdx, prefix, options) => {
  * - `*` to match zero or more characters in a path segment
  * - `?` to match one character in a path segment
  * - `**` to match any number of path segments, including none
- * - `{}` to group conditions (e.g. `{html,txt}`)
- * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]` character classes
+ * - `{}` to group conditions (e.g. `{html,txt}`), nested, and `{1..3}` ranges
+ * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]`, `[[:alpha:]]` character classes
  * - Extended globbing (when `extglob: true` option is set):
  *   - `?(pattern-list)` zero or one occurrence
  *   - `*(pattern-list)` zero or more occurrences
@@ -82,141 +398,32 @@ const parseExtGlob = (pattern, startIdx, prefix, options) => {
  *   - `!(pattern-list)` anything except the patterns
  */
 const toRegex = (pattern, options) => {
-    let regexStr = '';
-    let i = 0;
-    // Helper to parse a brace group like {a,b,c}. No nesting support.
-    const parseBraceGroup = () => {
-        // Assume current char is '{'
-        i++; // skip '{'
-        const parts = [];
-        let cur = '';
-        let closed = false;
-        while (i < pattern.length) {
-            const ch = pattern[i];
-            if (ch === '}') {
-                parts.push(cur);
-                i++; // consume '}'
-                closed = true;
-                break;
-            }
-            if (ch === ',') {
-                parts.push(cur);
-                cur = '';
-                i++;
-                continue;
-            }
-            cur += ch;
-            i++;
-        }
-        if (!closed) {
-            // treat as literal '{...'
-            return '\\{' + escapeRe(cur);
-        }
-        // Convert each part recursively to support globs inside braces
-        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 **
-                if (pattern[i + 1] === '*') {
-                    // Collapse consecutive * beyond two (e.g., *** -> **)
-                    let j = i + 2;
-                    while (pattern[j] === '*')
-                        j++;
-                    // If followed by a slash, make it optional to allow zero segments
-                    if (pattern[j] === '/') {
-                        regexStr += '(?:.*/)?';
-                        i = j + 1; // consume **/
-                    }
-                    else {
-                        regexStr += '.*';
-                        i = j; // consume **
-                    }
-                }
-                else {
-                    regexStr += '[^/]*';
-                    i++;
-                }
-                break;
-            }
-            case '?':
-                regexStr += '[^/]';
-                i++;
-                break;
-            case '[': {
-                // Copy character class as-is with support for leading '!'
-                let cls = '[';
-                i++;
-                if (i < pattern.length && pattern[i] === '!') {
-                    cls += '^';
-                    i++;
-                }
-                // if first after [ or [^ is ']' include it literally
-                if (i < pattern.length && pattern[i] === ']') {
-                    cls += ']';
-                    i++;
-                }
-                while (i < pattern.length && pattern[i] !== ']') {
-                    const ch = pattern[i];
-                    // Escape backslash inside class
-                    cls += ch === '\\' ? '\\\\' : ch;
-                    i++;
-                }
-                if (i < pattern.length && pattern[i] === ']') {
-                    cls += ']';
-                    i++;
-                }
-                else {
-                    // Unclosed class -> treat '[' literally
-                    regexStr += '\\[';
+    const nodot = options?.dot === false;
+    let source;
+    if (pattern.indexOf('{') < 0)
+        source = compile(pattern, extglob, nodot, '', true);
+    else {
+        const set = (0, exports.expandBraces)(pattern);
+        const length = set.length;
+        if (length === 1)
+            source = compile(set[0], extglob, nodot, '', true);
+        else {
+            const seen = new Set();
+            source = '(?:';
+            for (let i = 0; i < length; i++) {
+                const one = set[i];
+                if (seen.has(one))
                     continue;
-                }
-                regexStr += cls;
-                break;
+                if (seen.size)
+                    source += '|';
+                seen.add(one);
+                source += compile(one, extglob, nodot, '', true);
             }
-            case '{': {
-                regexStr += parseBraceGroup();
-                break;
-            }
-            case '/':
-                regexStr += '/';
-                i++;
-                break;
-            case '.':
-            case '^':
-            case '$':
-            case '+':
-            case '(':
-            case ')':
-            case '|':
-            case '\\':
-                regexStr += `\\${char}`;
-                i++;
-                break;
-            default:
-                regexStr += char;
-                i++;
-                break;
+            source += ')';
         }
     }
-    const flags = options?.nocase ? 'i' : '';
-    return new RegExp('^' + regexStr + '$', flags);
+    return new RegExp('^' + source + '$', options?.nocase ? 'i' : '');
 };
 exports.toRegex = toRegex;
 const isRegExp = /^\/(.{1,4096})\/([gimsuy]{0,6})$/;

package/package.json

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