fix: respect dot option in brace alternatives

Apply the leading-dot guard to brace alternatives starting with `*` or
`!(...)` at path-segment boundaries, including alternatives after commas.
Only add the guard when the `dot` option is disabled.

Preserve literal braces and braces embedded within a segment, and add
regression coverage for mrmlnc/fast-glob#405.

Author: mrmlnc

lib/parse.js

@@ -521,6 +521,16 @@ const parse = (input, options) => {
   };
 
   const extglobOpen = (type, value) => {
+    const brace = braces[braces.length - 1];
+    const isBrace = brace && stack[stack.length - 1] === 'braces' &&
+      (brace.prev.type === 'bos' || brace.prev.type === 'slash') &&
+      (prev.type === 'comma' || (prev.type === 'brace' && prev.value === '{'));
+
+    if (nodot && type === 'negate' && isBrace) {
+      state.output += nodot;
+      prev.output += nodot;
+    }
+
     const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
 
     token.prev = prev;
@@ -1257,11 +1267,18 @@ const parse = (input, options) => {
     }
 
     const token = { type: 'star', value, output: star };
+    const brace = braces[braces.length - 1];
+    const isBrace = brace && stack[stack.length - 1] === 'braces' &&
+      (brace.prev.type === 'bos' || brace.prev.type === 'slash') &&
+      (prev.type === 'comma' || (prev.type === 'brace' && prev.value === '{'));
 
     if (opts.bash === true) {
       token.output = '.*?';
       if (prev.type === 'bos' || prev.type === 'slash') {
         token.output = nodot + token.output;
+      } else if (isBrace) {
+        state.output += nodot;
+        prev.output += nodot;
       }
       push(token);
       continue;
@@ -1273,7 +1290,7 @@ const parse = (input, options) => {
       continue;
     }
 
-    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot' || isBrace) {
       if (prev.type === 'dot') {
         state.output += NO_DOT_SLASH;
         prev.output += NO_DOT_SLASH;

test/braces.js

@@ -25,6 +25,9 @@ describe('braces', () => {
     assert(isMatch('a {abc} b', 'a {abc} b'));
     assert(isMatch('a {a-b-c} b', 'a {a-b-c} b'));
     assert(isMatch('a {a.c} b', 'a {a.c} b'));
+    assert(isMatch('{.foo}', '{*}'));
+    assert(isMatch('{.foo}', '{*}', { bash: true }));
+    assert(isMatch('{!.foo}', '{!(x)}'));
   });
 
   it('should match literal braces when escaped', () => {

test/extglobs.js

@@ -86,6 +86,81 @@ describe('extglobs', () => {
       assert(isMatch('/file.dhello.ts', '/!(*.d).@(ts)'));
     });
 
+    it('should apply dotfile rules to brace alternatives at segment starts', () => {
+      const pattern = '**/{!(*.d).mts,!(*.d).cts,*.{mjs,cjs,js}}';
+      const opts = { dot: false };
+      const dotOpts = { dot: true };
+
+      assert(!isMatch('.cjs', pattern, opts));
+      assert(!isMatch('.cts', pattern, opts));
+      assert(!isMatch('.js', pattern, opts));
+      assert(!isMatch('.mjs', pattern, opts));
+      assert(!isMatch('.mts', pattern, opts));
+      assert(isMatch('a.mjs', pattern, opts));
+      assert(isMatch('ad.cts', pattern, opts));
+      assert(isMatch('ad.mts', pattern, opts));
+      assert(!isMatch('a/.cjs', pattern, opts));
+      assert(!isMatch('a/.cts', pattern, opts));
+      assert(!isMatch('a/.js', pattern, opts));
+      assert(!isMatch('a/.mjs', pattern, opts));
+      assert(!isMatch('a/.mts', pattern, opts));
+      assert(isMatch('a/a.mjs', pattern, opts));
+      assert(isMatch('a/ad.cts', pattern, opts));
+      assert(isMatch('a/ad.mts', pattern, opts));
+
+      assert(isMatch('.cjs', pattern, dotOpts));
+      assert(isMatch('.cts', pattern, dotOpts));
+      assert(isMatch('.js', pattern, dotOpts));
+      assert(isMatch('.mjs', pattern, dotOpts));
+      assert(isMatch('.mts', pattern, dotOpts));
+      assert(isMatch('a.mjs', pattern, dotOpts));
+      assert(isMatch('ad.cts', pattern, dotOpts));
+      assert(isMatch('ad.mts', pattern, dotOpts));
+      assert(isMatch('a/.cjs', pattern, dotOpts));
+      assert(isMatch('a/.cts', pattern, dotOpts));
+      assert(isMatch('a/.js', pattern, dotOpts));
+      assert(isMatch('a/.mjs', pattern, dotOpts));
+      assert(isMatch('a/.mts', pattern, dotOpts));
+      assert(isMatch('a/a.mjs', pattern, dotOpts));
+      assert(isMatch('a/ad.cts', pattern, dotOpts));
+      assert(isMatch('a/ad.mts', pattern, dotOpts));
+    });
+
+    it('should apply dotfile rules only at segment starts', () => {
+      assert(isMatch('.foo', '**/{.foo,*}'));
+      assert(!isMatch('.bar', '**/{.foo,*}'));
+      assert(isMatch('a.foo', 'a{*,b}'));
+    });
+
+    it('should apply dotfile rules to first and subsequent brace alternatives', () => {
+      assert(!isMatch('.js', '**/{*.js,x}', { dot: false }));
+      assert(!isMatch('a/.js', '**/{*.js,x}', { dot: false }));
+      assert(isMatch('.js', '**/{*.js,x}', { dot: true }));
+      assert(isMatch('a/.js', '**/{*.js,x}', { dot: true }));
+
+      assert(!isMatch('.js', '**/{x,*.js}', { dot: false }));
+      assert(!isMatch('a/.js', '**/{x,*.js}', { dot: false }));
+      assert(isMatch('.js', '**/{x,*.js}', { dot: true }));
+      assert(isMatch('a/.js', '**/{x,*.js}', { dot: true }));
+
+      assert(!isMatch('.mts', '**/{!(*.d).mts,x}', { dot: false }));
+      assert(!isMatch('a/.mts', '**/{!(*.d).mts,x}', { dot: false }));
+      assert(isMatch('.mts', '**/{!(*.d).mts,x}', { dot: true }));
+      assert(isMatch('a/.mts', '**/{!(*.d).mts,x}', { dot: true }));
+
+      assert(!isMatch('.mts', '**/{x,!(*.d).mts}', { dot: false }));
+      assert(!isMatch('a/.mts', '**/{x,!(*.d).mts}', { dot: false }));
+      assert(isMatch('.mts', '**/{x,!(*.d).mts}', { dot: true }));
+      assert(isMatch('a/.mts', '**/{x,!(*.d).mts}', { dot: true }));
+
+      assert(!isMatch('.js', '{*.js,x}', { bash: true }));
+      assert(isMatch('a.js', '{*.js,x}', { bash: true }));
+      assert(!isMatch('.js', '{x,*.js}', { bash: true }));
+      assert(isMatch('a.js', '{x,*.js}', { bash: true }));
+      assert(isMatch('a,.js', '{x,@(a,*.js)}'));
+      assert(isMatch('a,.mts', '{x,@(a,!(*.d).mts)}'));
+    });
+
     it('should support negation extglobs in patterns with slashes', () => {
       assert(!isMatch('foo/abc', 'foo/!(abc)'));
       assert(isMatch('foo/bar', 'foo/!(abc)'));
@@ -292,6 +367,13 @@ describe('extglobs', () => {
       assert(isMatch('bb.md', '*(a|b).md'));
     });
 
+    it('should preserve zero-length *(...) matches in brace alternatives', () => {
+      assert(isMatch('.md', '{*(a|b).md,x}'));
+      assert(isMatch('a/.md', 'a/{x,*(a|b).md}'));
+      assert(!isMatch('.a.md', '{*(a|b).md,x}', { noextglob: true }));
+      assert(isMatch('a.md', '{*(a|b).md,x}', { noextglob: true }));
+    });
+
     it('should support matching file extensions with ?(...)', () => {
       assert(!isMatch('a.js', '?(a|b).md'));
       assert(!isMatch('bb.md', '?(a|b).md'));
@@ -770,4 +852,3 @@ describe('extglobs', () => {
     assert.deepStrictEqual(match(['foo', ' foo '], '(f|o)+\\b'), ['foo'], 'Should match word boundaries');
   });
 });
-