@quilted/create 0.2.44 → 0.2.45

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @quilted/create
 
+## 0.2.45
+
+### Patch Changes
+
+- [`ee468bc`](https://github.com/lemonmade/quilt/commit/ee468bc1021c5a81535b22409f990c0003b93fc4) Thanks [@lemonmade](https://github.com/lemonmade)! - Update template node version
+
+- [`a2f9cbd`](https://github.com/lemonmade/quilt/commit/a2f9cbdee1f81b1fbc32d832c96511a194084a4b) Thanks [@lemonmade](https://github.com/lemonmade)! - More development dependency updates
+
 ## 0.2.44
 
 ### Patch Changes

package/build/esm/_virtual/index3.mjs

@@ -1,5 +1,5 @@
 import { getDefaultExportFromCjs } from './_commonjsHelpers.mjs';
-import { __require as requireOut } from '../node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/index.mjs';
+import { __require as requireOut } from '../node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/index.mjs';
 
 var outExports = requireOut();
 const fastGlob = /*@__PURE__*/getDefaultExportFromCjs(outExports);

package/build/esm/_virtual/index7.mjs

@@ -1,3 +1,3 @@
-var utils = {};
+var dirGlob = {exports: {}};
 
-export { utils as __exports };
+export { dirGlob as __module };

package/build/esm/_virtual/index8.mjs

@@ -1,3 +1,3 @@
-var dirGlob = {exports: {}};
+var utils = {};
 
-export { dirGlob as __module };
+export { utils as __exports };

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/index.mjs

@@ -30,8 +30,8 @@ function requireBraces() {
   const braces = (input, options = {}) => {
     let output = [];
     if (Array.isArray(input)) {
-      for (let pattern of input) {
-        let result = braces.create(pattern, options);
+      for (const pattern of input) {
+        const result = braces.create(pattern, options);
         if (Array.isArray(result)) {
           output.push(...result);
         } else {

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/lib/compile.mjs

@@ -1,4 +1,4 @@
-import { __require as requireFillRange } from '../../../../fill-range@7.0.1/node_modules/fill-range/index.mjs';
+import { __require as requireFillRange } from '../../../../fill-range@7.1.1/node_modules/fill-range/index.mjs';
 import { __require as requireUtils } from './utils.mjs';
 
 var compile_1;
@@ -9,16 +9,17 @@ function requireCompile() {
   const fill = requireFillRange();
   const utils = requireUtils();
   const compile = (ast, options = {}) => {
-    let walk = (node, parent = {}) => {
-      let invalidBlock = utils.isInvalidBrace(parent);
-      let invalidNode = node.invalid === true && options.escapeInvalid === true;
-      let invalid = invalidBlock === true || invalidNode === true;
-      let prefix = options.escapeInvalid === true ? '\\' : '';
+    const walk = (node, parent = {}) => {
+      const invalidBlock = utils.isInvalidBrace(parent);
+      const invalidNode = node.invalid === true && options.escapeInvalid === true;
+      const invalid = invalidBlock === true || invalidNode === true;
+      const prefix = options.escapeInvalid === true ? '\\' : '';
       let output = '';
       if (node.isOpen === true) {
         return prefix + node.value;
       }
       if (node.isClose === true) {
+        console.log('node.isClose', prefix, node.value);
         return prefix + node.value;
       }
       if (node.type === 'open') {
@@ -34,18 +35,19 @@ function requireCompile() {
         return node.value;
       }
       if (node.nodes && node.ranges > 0) {
-        let args = utils.reduce(node.nodes);
-        let range = fill(...args, {
+        const args = utils.reduce(node.nodes);
+        const range = fill(...args, {
           ...options,
           wrap: false,
-          toRegex: true
+          toRegex: true,
+          strictZeros: true
         });
         if (range.length !== 0) {
           return args.length > 1 && range.length > 1 ? `(${range})` : range;
         }
       }
       if (node.nodes) {
-        for (let child of node.nodes) {
+        for (const child of node.nodes) {
           output += walk(child, node);
         }
       }

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/lib/constants.mjs

@@ -4,7 +4,7 @@ function requireConstants() {
   if (hasRequiredConstants) return constants;
   hasRequiredConstants = 1;
   constants = {
-    MAX_LENGTH: 1024 * 64,
+    MAX_LENGTH: 10000,
     // Digits
     CHAR_0: '0',
     /* 0 */
@@ -100,7 +100,6 @@ function requireConstants() {
     /* | */
     CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
   };
-
   return constants;
 }
 

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/lib/expand.mjs

@@ -1,4 +1,4 @@
-import { __require as requireFillRange } from '../../../../fill-range@7.0.1/node_modules/fill-range/index.mjs';
+import { __require as requireFillRange } from '../../../../fill-range@7.1.1/node_modules/fill-range/index.mjs';
 import { __require as requireStringify } from './stringify.mjs';
 import { __require as requireUtils } from './utils.mjs';
 
@@ -11,16 +11,16 @@ function requireExpand() {
   const stringify = requireStringify();
   const utils = requireUtils();
   const append = (queue = '', stash = '', enclose = false) => {
-    let result = [];
+    const result = [];
     queue = [].concat(queue);
     stash = [].concat(stash);
     if (!stash.length) return queue;
     if (!queue.length) {
       return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
     }
-    for (let item of queue) {
+    for (const item of queue) {
       if (Array.isArray(item)) {
-        for (let value of item) {
+        for (const value of item) {
           result.push(append(value, stash, enclose));
         }
       } else {
@@ -33,8 +33,8 @@ function requireExpand() {
     return utils.flatten(result);
   };
   const expand = (ast, options = {}) => {
-    let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
-    let walk = (node, parent = {}) => {
+    const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
+    const walk = (node, parent = {}) => {
       node.queue = [];
       let p = parent;
       let q = parent.queue;
@@ -51,7 +51,7 @@ function requireExpand() {
         return;
       }
       if (node.nodes && node.ranges > 0) {
-        let args = utils.reduce(node.nodes);
+        const args = utils.reduce(node.nodes);
         if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
           throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
         }
@@ -63,7 +63,7 @@ function requireExpand() {
         node.nodes = [];
         return;
       }
-      let enclose = utils.encloseBrace(node);
+      const enclose = utils.encloseBrace(node);
       let queue = node.queue;
       let block = node;
       while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
@@ -71,7 +71,7 @@ function requireExpand() {
         queue = block.queue;
       }
       for (let i = 0; i < node.nodes.length; i++) {
-        let child = node.nodes[i];
+        const child = node.nodes[i];
         if (child.type === 'comma' && node.type === 'brace') {
           if (i === 1) queue.push('');
           queue.push('');

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/lib/parse.mjs

@@ -50,21 +50,21 @@ function requireParse() {
     if (typeof input !== 'string') {
       throw new TypeError('Expected a string');
     }
-    let opts = options || {};
-    let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    const opts = options || {};
+    const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
     if (input.length > max) {
       throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
     }
-    let ast = {
+    const ast = {
       type: 'root',
       input,
       nodes: []
     };
-    let stack = [ast];
+    const stack = [ast];
     let block = ast;
     let prev = ast;
     let brackets = 0;
-    let length = input.length;
+    const length = input.length;
     let index = 0;
     let depth = 0;
     let value;
@@ -196,7 +196,7 @@ function requireParse() {
        */
 
       if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
-        let open = value;
+        const open = value;
         let next;
         if (options.keepQuotes !== true) {
           value = '';
@@ -225,8 +225,8 @@ function requireParse() {
 
       if (value === CHAR_LEFT_CURLY_BRACE) {
         depth++;
-        let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
-        let brace = {
+        const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+        const brace = {
           type: 'brace',
           open: true,
           close: false,
@@ -257,7 +257,7 @@ function requireParse() {
           });
           continue;
         }
-        let type = 'close';
+        const type = 'close';
         block = stack.pop();
         block.close = true;
         push({
@@ -276,7 +276,7 @@ function requireParse() {
       if (value === CHAR_COMMA && depth > 0) {
         if (block.ranges > 0) {
           block.ranges = 0;
-          let open = block.nodes.shift();
+          const open = block.nodes.shift();
           block.nodes = [open, {
             type: 'text',
             value: stringify(block)
@@ -295,7 +295,7 @@ function requireParse() {
        */
 
       if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
-        let siblings = block.nodes;
+        const siblings = block.nodes;
         if (depth === 0 || siblings.length === 0) {
           push({
             type: 'text',
@@ -319,7 +319,7 @@ function requireParse() {
         }
         if (prev.type === 'range') {
           siblings.pop();
-          let before = siblings[siblings.length - 1];
+          const before = siblings[siblings.length - 1];
           before.value += prev.value + value;
           prev = before;
           block.ranges--;
@@ -356,8 +356,8 @@ function requireParse() {
         });
 
         // get the location of the block on parent.nodes (block's siblings)
-        let parent = stack[stack.length - 1];
-        let index = parent.nodes.indexOf(block);
+        const parent = stack[stack.length - 1];
+        const index = parent.nodes.indexOf(block);
         // replace the (invalid) block with it's nodes
         parent.nodes.splice(index, 1, ...block.nodes);
       }

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/lib/stringify.mjs

@@ -7,9 +7,9 @@ function requireStringify() {
   hasRequiredStringify = 1;
   const utils = requireUtils();
   stringify = (ast, options = {}) => {
-    let stringify = (node, parent = {}) => {
-      let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
-      let invalidNode = node.invalid === true && options.escapeInvalid === true;
+    const stringify = (node, parent = {}) => {
+      const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+      const invalidNode = node.invalid === true && options.escapeInvalid === true;
       let output = '';
       if (node.value) {
         if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
@@ -21,7 +21,7 @@ function requireStringify() {
         return node.value;
       }
       if (node.nodes) {
-        for (let child of node.nodes) {
+        for (const child of node.nodes) {
           output += stringify(child);
         }
       }

package/build/esm/node_modules/.pnpm/{braces@3.0.2 → braces@3.0.3}/node_modules/braces/lib/utils.mjs

@@ -37,7 +37,7 @@ function requireUtils() {
      */
 
     exports.escapeNode = (block, n = 0, type) => {
-      let node = block.nodes[n];
+      const node = block.nodes[n];
       if (!node) return;
       if (type && node.type === type || node.type === 'open' || node.type === 'close') {
         if (node.escaped !== true) {
@@ -107,8 +107,14 @@ function requireUtils() {
       const result = [];
       const flat = arr => {
         for (let i = 0; i < arr.length; i++) {
-          let ele = arr[i];
-          Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+          const ele = arr[i];
+          if (Array.isArray(ele)) {
+            flat(ele);
+            continue;
+          }
+          if (ele !== undefined) {
+            result.push(ele);
+          }
         }
         return result;
       };

package/build/esm/node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.mjs

@@ -1,4 +1,4 @@
-import { __module as dirGlob } from '../../../../../_virtual/index8.mjs';
+import { __module as dirGlob } from '../../../../../_virtual/index7.mjs';
 import path__default from 'node:path';
 import { __require as requirePathType } from '../../../path-type@4.0.0/node_modules/path-type/index.mjs';
 
@@ -51,7 +51,6 @@ function requireDirGlob() {
     }));
     return [].concat.apply([], globs); // eslint-disable-line prefer-spread
   };
-
   dirGlob.exports.sync = (input, options) => {
     options = {
       cwd: process.cwd(),
@@ -63,7 +62,6 @@ function requireDirGlob() {
     const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
     return [].concat.apply([], globs); // eslint-disable-line prefer-spread
   };
-
   return dirGlob.exports;
 }
 

package/build/esm/node_modules/.pnpm/{fast-glob@3.2.12 → fast-glob@3.3.3}/node_modules/fast-glob/out/index.mjs

@@ -1,5 +1,4 @@
 import { __require as requireTasks } from './managers/tasks.mjs';
-import { __require as requirePatterns } from './managers/patterns.mjs';
 import { __require as requireAsync } from './providers/async.mjs';
 import { __require as requireStream } from './providers/stream.mjs';
 import { __require as requireSync } from './providers/sync.mjs';
@@ -12,7 +11,6 @@ function requireOut() {
   if (hasRequiredOut) return out;
   hasRequiredOut = 1;
   const taskManager = requireTasks();
-  const patternManager = requirePatterns();
   const async_1 = requireAsync();
   const stream_1 = requireStream();
   const sync_1 = requireSync();
@@ -27,6 +25,10 @@ function requireOut() {
   // https://github.com/typescript-eslint/typescript-eslint/issues/60
   // eslint-disable-next-line no-redeclare
   (function (FastGlob) {
+    FastGlob.glob = FastGlob;
+    FastGlob.globSync = sync;
+    FastGlob.globStream = stream;
+    FastGlob.async = FastGlob;
     function sync(source, options) {
       assertPatternsInput(source);
       const works = getWorks(source, sync_1.default, options);
@@ -36,17 +38,17 @@ function requireOut() {
     function stream(source, options) {
       assertPatternsInput(source);
       const works = getWorks(source, stream_1.default, options);
-      /**
-       * The stream returned by the provider cannot work with an asynchronous iterator.
-       * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
-       * This affects performance (+25%). I don't see best solution right now.
+      /**
+       * The stream returned by the provider cannot work with an asynchronous iterator.
+       * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+       * This affects performance (+25%). I don't see best solution right now.
        */
       return utils.stream.merge(works);
     }
     FastGlob.stream = stream;
     function generateTasks(source, options) {
       assertPatternsInput(source);
-      const patterns = patternManager.transform([].concat(source));
+      const patterns = [].concat(source);
       const settings = new settings_1.default(options);
       return taskManager.generate(patterns, settings);
     }
@@ -62,9 +64,38 @@ function requireOut() {
       return utils.path.escape(source);
     }
     FastGlob.escapePath = escapePath;
+    function convertPathToPattern(source) {
+      assertPatternsInput(source);
+      return utils.path.convertPathToPattern(source);
+    }
+    FastGlob.convertPathToPattern = convertPathToPattern;
+    (function (posix) {
+      function escapePath(source) {
+        assertPatternsInput(source);
+        return utils.path.escapePosixPath(source);
+      }
+      posix.escapePath = escapePath;
+      function convertPathToPattern(source) {
+        assertPatternsInput(source);
+        return utils.path.convertPosixPathToPattern(source);
+      }
+      posix.convertPathToPattern = convertPathToPattern;
+    })(FastGlob.posix || (FastGlob.posix = {}));
+    (function (win32) {
+      function escapePath(source) {
+        assertPatternsInput(source);
+        return utils.path.escapeWindowsPath(source);
+      }
+      win32.escapePath = escapePath;
+      function convertPathToPattern(source) {
+        assertPatternsInput(source);
+        return utils.path.convertWindowsPathToPattern(source);
+      }
+      win32.convertPathToPattern = convertPathToPattern;
+    })(FastGlob.win32 || (FastGlob.win32 = {}));
   })(FastGlob || (FastGlob = {}));
   function getWorks(source, _Provider, options) {
-    const patterns = patternManager.transform([].concat(source));
+    const patterns = [].concat(source);
     const settings = new settings_1.default(options);
     const tasks = taskManager.generate(patterns, settings);
     const provider = new _Provider(settings);

package/build/esm/node_modules/.pnpm/{fast-glob@3.2.12 → fast-glob@3.3.3}/node_modules/fast-glob/out/managers/tasks.mjs

@@ -10,9 +10,11 @@ function requireTasks() {
   });
   tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
   const utils = requireUtils();
-  function generate(patterns, settings) {
+  function generate(input, settings) {
+    const patterns = processPatterns(input, settings);
+    const ignore = processPatterns(settings.ignore, settings);
     const positivePatterns = getPositivePatterns(patterns);
-    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
     const staticPatterns = positivePatterns.filter(pattern => utils.pattern.isStaticPattern(pattern, settings));
     const dynamicPatterns = positivePatterns.filter(pattern => utils.pattern.isDynamicPattern(pattern, settings));
     const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */false);
@@ -20,11 +22,39 @@ function requireTasks() {
     return staticTasks.concat(dynamicTasks);
   }
   tasks.generate = generate;
-  /**
-   * Returns tasks grouped by basic pattern directories.
-   *
-   * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
-   * This is necessary because directory traversal starts at the base directory and goes deeper.
+  function processPatterns(input, settings) {
+    let patterns = input;
+    /**
+     * The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
+     * and some problems with the micromatch package (see fast-glob issues: #365, #394).
+     *
+     * To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
+     * in matching in the case of a large set of patterns after expansion.
+     */
+    if (settings.braceExpansion) {
+      patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
+    }
+    /**
+     * If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
+     * at any nesting level.
+     *
+     * We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
+     * the pattern in the filter before creating a regular expression. There is no need to change the patterns
+     * in the application. Only on the input.
+     */
+    if (settings.baseNameMatch) {
+      patterns = patterns.map(pattern => pattern.includes('/') ? pattern : `**/${pattern}`);
+    }
+    /**
+     * This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
+     */
+    return patterns.map(pattern => utils.pattern.removeDuplicateSlashes(pattern));
+  }
+  /**
+   * Returns tasks grouped by basic pattern directories.
+   *
+   * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+   * This is necessary because directory traversal starts at the base directory and goes deeper.
    */
   function convertPatternsToTasks(positive, negative, dynamic) {
     const tasks = [];
@@ -33,9 +63,9 @@ function requireTasks() {
     const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
     const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
     tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-    /*
-     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
-     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
+    /*
+     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
+     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
      */
     if ('.' in insideCurrentDirectoryGroup) {
       tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));

package/build/esm/node_modules/.pnpm/{fast-glob@3.2.12 → fast-glob@3.3.3}/node_modules/fast-glob/out/providers/filters/deep.mjs

@@ -42,8 +42,8 @@ function requireDeep() {
       return this._isSkippedByNegativePatterns(filepath, negativeRe);
     }
     _isSkippedByDeep(basePath, entryPath) {
-      /**
-       * Avoid unnecessary depth calculations when it doesn't matter.
+      /**
+       * Avoid unnecessary depth calculations when it doesn't matter.
        */
       if (this._settings.deep === Infinity) {
         return false;

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/filters/entry.mjs

@@ -0,0 +1,101 @@
+import { __exports as entry } from '../../../../../../../../_virtual/entry.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
+
+var hasRequiredEntry;
+function requireEntry() {
+  if (hasRequiredEntry) return entry;
+  hasRequiredEntry = 1;
+  Object.defineProperty(entry, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class EntryFilter {
+    constructor(_settings, _micromatchOptions) {
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+      this.index = new Map();
+    }
+    getFilter(positive, negative) {
+      const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
+      const patterns = {
+        positive: {
+          all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
+        },
+        negative: {
+          absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), {
+            dot: true
+          })),
+          relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), {
+            dot: true
+          }))
+        }
+      };
+      return entry => this._filter(entry, patterns);
+    }
+    _filter(entry, patterns) {
+      const filepath = utils.path.removeLeadingDotSegment(entry.path);
+      if (this._settings.unique && this._isDuplicateEntry(filepath)) {
+        return false;
+      }
+      if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+        return false;
+      }
+      const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
+      if (this._settings.unique && isMatched) {
+        this._createIndexRecord(filepath);
+      }
+      return isMatched;
+    }
+    _isDuplicateEntry(filepath) {
+      return this.index.has(filepath);
+    }
+    _createIndexRecord(filepath) {
+      this.index.set(filepath, undefined);
+    }
+    _onlyFileFilter(entry) {
+      return this._settings.onlyFiles && !entry.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry) {
+      return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+    }
+    _isMatchToPatternsSet(filepath, patterns, isDirectory) {
+      const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
+      if (!isMatched) {
+        return false;
+      }
+      const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
+      if (isMatchedByRelativeNegative) {
+        return false;
+      }
+      const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
+      if (isMatchedByAbsoluteNegative) {
+        return false;
+      }
+      return true;
+    }
+    _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
+      if (patternsRe.length === 0) {
+        return false;
+      }
+      const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+      return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
+    }
+    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
+      if (patternsRe.length === 0) {
+        return false;
+      }
+      // Trying to match files and directories by patterns.
+      const isMatched = utils.pattern.matchAny(filepath, patternsRe);
+      // A pattern with a trailling slash can be used for directory matching.
+      // To apply such pattern, we need to add a tralling slash to the path.
+      if (!isMatched && isDirectory) {
+        return utils.pattern.matchAny(filepath + '/', patternsRe);
+      }
+      return isMatched;
+    }
+  }
+  entry.default = EntryFilter;
+  return entry;
+}
+
+export { requireEntry as __require };

package/build/esm/node_modules/.pnpm/{fast-glob@3.2.12 → fast-glob@3.3.3}/node_modules/fast-glob/out/providers/matchers/matcher.mjs

@@ -18,12 +18,7 @@ function requireMatcher() {
       this._fillStorage();
     }
     _fillStorage() {
-      /**
-       * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
-       * So, before expand patterns with brace expansion into separated patterns.
-       */
-      const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
-      for (const pattern of patterns) {
+      for (const pattern of this._patterns) {
         const segments = this._getPatternSegments(pattern);
         const sections = this._splitSegmentsIntoSections(segments);
         this._storage.push({

package/build/esm/node_modules/.pnpm/{fast-glob@3.2.12 → fast-glob@3.3.3}/node_modules/fast-glob/out/providers/matchers/partial.mjs

@@ -16,12 +16,12 @@ function requirePartial() {
       const patterns = this._storage.filter(info => !info.complete || info.segments.length > levels);
       for (const pattern of patterns) {
         const section = pattern.sections[0];
-        /**
-         * In this case, the pattern has a globstar and we must read all directories unconditionally,
-         * but only if the level has reached the end of the first group.
-         *
-         * fixtures/{a,b}/**
-         *  ^ true/false  ^ always true
+        /**
+         * In this case, the pattern has a globstar and we must read all directories unconditionally,
+         * but only if the level has reached the end of the first group.
+         *
+         * fixtures/{a,b}/**
+         *  ^ true/false  ^ always true
         */
         if (!pattern.complete && levels > section.length) {
           return true;