@quilted/create 0.2.43 → 0.2.45

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

@@ -1,68 +1,68 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.mjs';
-import { __module as dirGlob$1 } from '../../../../../_virtual/index2.mjs';
+import { __module as dirGlob } from '../../../../../_virtual/index7.mjs';
 import path__default from 'node:path';
-import '../../../path-type@4.0.0/node_modules/path-type/index.mjs';
-import { __exports as pathType$1 } from '../../../../../_virtual/index3.mjs';
+import { __require as requirePathType } from '../../../path-type@4.0.0/node_modules/path-type/index.mjs';
 
-const path = path__default;
-const pathType = pathType$1;
-const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
-const getPath = (filepath, cwd) => {
-  const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
-  return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
-};
-const addExtensions = (file, extensions) => {
-  if (path.extname(file)) {
-    return `**/${file}`;
-  }
-  return `**/${file}.${getExtensions(extensions)}`;
-};
-const getGlob = (directory, options) => {
-  if (options.files && !Array.isArray(options.files)) {
-    throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
-  }
-  if (options.extensions && !Array.isArray(options.extensions)) {
-    throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
-  }
-  if (options.files && options.extensions) {
-    return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
-  }
-  if (options.files) {
-    return options.files.map(x => path.posix.join(directory, `**/${x}`));
-  }
-  if (options.extensions) {
-    return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
-  }
-  return [path.posix.join(directory, '**')];
-};
-dirGlob$1.exports = async (input, options) => {
-  options = {
-    cwd: process.cwd(),
-    ...options
+var hasRequiredDirGlob;
+function requireDirGlob() {
+  if (hasRequiredDirGlob) return dirGlob.exports;
+  hasRequiredDirGlob = 1;
+  const path = path__default;
+  const pathType = requirePathType();
+  const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
+  const getPath = (filepath, cwd) => {
+    const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
+    return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
   };
-  if (typeof options.cwd !== 'string') {
-    throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
-  }
-  const globs = await Promise.all([].concat(input).map(async x => {
-    const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
-    return isDirectory ? getGlob(x, options) : x;
-  }));
-  return [].concat.apply([], globs); // eslint-disable-line prefer-spread
-};
-
-dirGlob$1.exports.sync = (input, options) => {
-  options = {
-    cwd: process.cwd(),
-    ...options
+  const addExtensions = (file, extensions) => {
+    if (path.extname(file)) {
+      return `**/${file}`;
+    }
+    return `**/${file}.${getExtensions(extensions)}`;
   };
-  if (typeof options.cwd !== 'string') {
-    throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
-  }
-  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
-};
-
-var dirGlobExports = dirGlob$1.exports;
-const dirGlob = /*@__PURE__*/getDefaultExportFromCjs(dirGlobExports);
+  const getGlob = (directory, options) => {
+    if (options.files && !Array.isArray(options.files)) {
+      throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+    }
+    if (options.extensions && !Array.isArray(options.extensions)) {
+      throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
+    }
+    if (options.files && options.extensions) {
+      return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
+    }
+    if (options.files) {
+      return options.files.map(x => path.posix.join(directory, `**/${x}`));
+    }
+    if (options.extensions) {
+      return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+    }
+    return [path.posix.join(directory, '**')];
+  };
+  dirGlob.exports = async (input, options) => {
+    options = {
+      cwd: process.cwd(),
+      ...options
+    };
+    if (typeof options.cwd !== 'string') {
+      throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+    }
+    const globs = await Promise.all([].concat(input).map(async x => {
+      const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
+      return isDirectory ? getGlob(x, options) : x;
+    }));
+    return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+  };
+  dirGlob.exports.sync = (input, options) => {
+    options = {
+      cwd: process.cwd(),
+      ...options
+    };
+    if (typeof options.cwd !== 'string') {
+      throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+    }
+    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;
+}
 
-export { dirGlob as default };
+export { requireDirGlob as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/index.mjs

@@ -0,0 +1,115 @@
+import { __require as requireTasks } from './managers/tasks.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';
+import { __require as requireSettings } from './settings.mjs';
+import { __require as requireUtils } from './utils/index.mjs';
+
+var out;
+var hasRequiredOut;
+function requireOut() {
+  if (hasRequiredOut) return out;
+  hasRequiredOut = 1;
+  const taskManager = requireTasks();
+  const async_1 = requireAsync();
+  const stream_1 = requireStream();
+  const sync_1 = requireSync();
+  const settings_1 = requireSettings();
+  const utils = requireUtils();
+  async function FastGlob(source, options) {
+    assertPatternsInput(source);
+    const works = getWorks(source, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
+  }
+  // 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);
+      return utils.array.flatten(works);
+    }
+    FastGlob.sync = sync;
+    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.
+       */
+      return utils.stream.merge(works);
+    }
+    FastGlob.stream = stream;
+    function generateTasks(source, options) {
+      assertPatternsInput(source);
+      const patterns = [].concat(source);
+      const settings = new settings_1.default(options);
+      return taskManager.generate(patterns, settings);
+    }
+    FastGlob.generateTasks = generateTasks;
+    function isDynamicPattern(source, options) {
+      assertPatternsInput(source);
+      const settings = new settings_1.default(options);
+      return utils.pattern.isDynamicPattern(source, settings);
+    }
+    FastGlob.isDynamicPattern = isDynamicPattern;
+    function escapePath(source) {
+      assertPatternsInput(source);
+      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 = [].concat(source);
+    const settings = new settings_1.default(options);
+    const tasks = taskManager.generate(patterns, settings);
+    const provider = new _Provider(settings);
+    return tasks.map(provider.read, provider);
+  }
+  function assertPatternsInput(input) {
+    const source = [].concat(input);
+    const isValidSource = source.every(item => utils.string.isString(item) && !utils.string.isEmpty(item));
+    if (!isValidSource) {
+      throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+    }
+  }
+  out = FastGlob;
+  return out;
+}
+
+export { requireOut as __require };

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

@@ -0,0 +1,120 @@
+import { __exports as tasks } from '../../../../../../../_virtual/tasks.mjs';
+import { __require as requireUtils } from '../utils/index.mjs';
+
+var hasRequiredTasks;
+function requireTasks() {
+  if (hasRequiredTasks) return tasks;
+  hasRequiredTasks = 1;
+  Object.defineProperty(tasks, "__esModule", {
+    value: true
+  });
+  tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+  const utils = requireUtils();
+  function generate(input, settings) {
+    const patterns = processPatterns(input, settings);
+    const ignore = processPatterns(settings.ignore, settings);
+    const positivePatterns = getPositivePatterns(patterns);
+    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);
+    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */true);
+    return staticTasks.concat(dynamicTasks);
+  }
+  tasks.generate = generate;
+  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 = [];
+    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
+    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.
+     */
+    if ('.' in insideCurrentDirectoryGroup) {
+      tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
+    } else {
+      tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+    }
+    return tasks;
+  }
+  tasks.convertPatternsToTasks = convertPatternsToTasks;
+  function getPositivePatterns(patterns) {
+    return utils.pattern.getPositivePatterns(patterns);
+  }
+  tasks.getPositivePatterns = getPositivePatterns;
+  function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map(utils.pattern.convertToPositivePattern);
+    return positive;
+  }
+  tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+  function groupPatternsByBaseDirectory(patterns) {
+    const group = {};
+    return patterns.reduce((collection, pattern) => {
+      const base = utils.pattern.getBaseDirectory(pattern);
+      if (base in collection) {
+        collection[base].push(pattern);
+      } else {
+        collection[base] = [pattern];
+      }
+      return collection;
+    }, group);
+  }
+  tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+  function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map(base => {
+      return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+  }
+  tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+  function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+      dynamic,
+      positive,
+      negative,
+      base,
+      patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+    };
+  }
+  tasks.convertPatternGroupToTask = convertPatternGroupToTask;
+  return tasks;
+}
+
+export { requireTasks as __require };

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

@@ -0,0 +1,36 @@
+import { __exports as async } from '../../../../../../../_virtual/async.mjs';
+import { __require as requireAsync$1 } from '../readers/async.mjs';
+import { __require as requireProvider } from './provider.mjs';
+
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", {
+    value: true
+  });
+  const async_1 = requireAsync$1();
+  const provider_1 = requireProvider();
+  class ProviderAsync extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new async_1.default(this._settings);
+    }
+    async read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const entries = await this.api(root, task, options);
+      return entries.map(entry => options.transform(entry));
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
+    }
+  }
+  async.default = ProviderAsync;
+  return async;
+}
+
+export { requireAsync as __require };

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

@@ -0,0 +1,75 @@
+import { __exports as deep } from '../../../../../../../../_virtual/deep.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
+import { __require as requirePartial } from '../matchers/partial.mjs';
+
+var hasRequiredDeep;
+function requireDeep() {
+  if (hasRequiredDeep) return deep;
+  hasRequiredDeep = 1;
+  Object.defineProperty(deep, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  const partial_1 = requirePartial();
+  class DeepFilter {
+    constructor(_settings, _micromatchOptions) {
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+    }
+    getFilter(basePath, positive, negative) {
+      const matcher = this._getMatcher(positive);
+      const negativeRe = this._getNegativePatternsRe(negative);
+      return entry => this._filter(basePath, entry, matcher, negativeRe);
+    }
+    _getMatcher(patterns) {
+      return new partial_1.default(patterns, this._settings, this._micromatchOptions);
+    }
+    _getNegativePatternsRe(patterns) {
+      const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+      return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+    }
+    _filter(basePath, entry, matcher, negativeRe) {
+      if (this._isSkippedByDeep(basePath, entry.path)) {
+        return false;
+      }
+      if (this._isSkippedSymbolicLink(entry)) {
+        return false;
+      }
+      const filepath = utils.path.removeLeadingDotSegment(entry.path);
+      if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+        return false;
+      }
+      return this._isSkippedByNegativePatterns(filepath, negativeRe);
+    }
+    _isSkippedByDeep(basePath, entryPath) {
+      /**
+       * Avoid unnecessary depth calculations when it doesn't matter.
+       */
+      if (this._settings.deep === Infinity) {
+        return false;
+      }
+      return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+    }
+    _getEntryLevel(basePath, entryPath) {
+      const entryPathDepth = entryPath.split('/').length;
+      if (basePath === '') {
+        return entryPathDepth;
+      }
+      const basePathDepth = basePath.split('/').length;
+      return entryPathDepth - basePathDepth;
+    }
+    _isSkippedSymbolicLink(entry) {
+      return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(entryPath, matcher) {
+      return !this._settings.baseNameMatch && !matcher.match(entryPath);
+    }
+    _isSkippedByNegativePatterns(entryPath, patternsRe) {
+      return !utils.pattern.matchAny(entryPath, patternsRe);
+    }
+  }
+  deep.default = DeepFilter;
+  return deep;
+}
+
+export { requireDeep as __require };

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.3.3/node_modules/fast-glob/out/providers/filters/error.mjs

@@ -0,0 +1,27 @@
+import { __exports as error } from '../../../../../../../../_virtual/error.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
+
+var hasRequiredError;
+function requireError() {
+  if (hasRequiredError) return error;
+  hasRequiredError = 1;
+  Object.defineProperty(error, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class ErrorFilter {
+    constructor(_settings) {
+      this._settings = _settings;
+    }
+    getFilter() {
+      return error => this._isNonFatalError(error);
+    }
+    _isNonFatalError(error) {
+      return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+    }
+  }
+  error.default = ErrorFilter;
+  return error;
+}
+
+export { requireError as __require };

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

@@ -0,0 +1,57 @@
+import { __exports as matcher } from '../../../../../../../../_virtual/matcher.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
+
+var hasRequiredMatcher;
+function requireMatcher() {
+  if (hasRequiredMatcher) return matcher;
+  hasRequiredMatcher = 1;
+  Object.defineProperty(matcher, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+      this._patterns = _patterns;
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+      this._storage = [];
+      this._fillStorage();
+    }
+    _fillStorage() {
+      for (const pattern of this._patterns) {
+        const segments = this._getPatternSegments(pattern);
+        const sections = this._splitSegmentsIntoSections(segments);
+        this._storage.push({
+          complete: sections.length <= 1,
+          pattern,
+          segments,
+          sections
+        });
+      }
+    }
+    _getPatternSegments(pattern) {
+      const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+      return parts.map(part => {
+        const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+        if (!dynamic) {
+          return {
+            dynamic: false,
+            pattern: part
+          };
+        }
+        return {
+          dynamic: true,
+          pattern: part,
+          patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+        };
+      });
+    }
+    _splitSegmentsIntoSections(segments) {
+      return utils.array.splitWhen(segments, segment => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+    }
+  }
+  matcher.default = Matcher;
+  return matcher;
+}
+
+export { requireMatcher as __require };