@quilted/create 0.1.56 → 0.1.58

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var TemplateTag = require('../TemplateTag/TemplateTag.cjs');
+var stripIndentTransformer = require('../stripIndentTransformer/stripIndentTransformer.cjs');
+var trimResultTransformer = require('../trimResultTransformer/trimResultTransformer.cjs');
+
+var stripIndent = new TemplateTag["default"](stripIndentTransformer["default"], trimResultTransformer["default"]);
+
+exports["default"] = stripIndent;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndentTransformer/stripIndentTransformer.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+/**
+ * strips indentation from a template literal
+ * @param  {String} type = 'initial' - whether to remove all indentation or just leading indentation. can be 'all' or 'initial'
+ * @return {Object}                  - a TemplateTag transformer
+ */
+var stripIndentTransformer = function stripIndentTransformer() {
+  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'initial';
+  return {
+    onEndResult: function onEndResult(endResult) {
+      if (type === 'initial') {
+        // remove the shortest leading indentation from each line
+        var match = endResult.match(/^[^\S\n]*(?=\S)/gm);
+        var indent = match && Math.min.apply(Math, _toConsumableArray(match.map(function (el) {
+          return el.length;
+        })));
+        if (indent) {
+          var regexp = new RegExp('^.{' + indent + '}', 'gm');
+          return endResult.replace(regexp, '');
+        }
+        return endResult;
+      }
+      if (type === 'all') {
+        // remove all indentation from each line
+        return endResult.replace(/^[^\S\n]+/gm, '');
+      }
+      throw new Error('Unknown type: ' + type);
+    }
+  };
+};
+
+exports["default"] = stripIndentTransformer;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var TemplateTag = require('../TemplateTag/TemplateTag.cjs');
+var stripIndentTransformer = require('../stripIndentTransformer/stripIndentTransformer.cjs');
+var trimResultTransformer = require('../trimResultTransformer/trimResultTransformer.cjs');
+
+new TemplateTag["default"](stripIndentTransformer["default"]('all'), trimResultTransformer["default"]);

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/trimResultTransformer/trimResultTransformer.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * TemplateTag transformer that trims whitespace on the end result of a tagged template
+ * @param  {String} side = '' - The side of the string to trim. Can be 'start' or 'end' (alternatively 'left' or 'right')
+ * @return {Object}           - a TemplateTag transformer
+ */
+var trimResultTransformer = function trimResultTransformer() {
+  var side = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return {
+    onEndResult: function onEndResult(endResult) {
+      if (side === '') {
+        return endResult.trim();
+      }
+
+      side = side.toLowerCase();
+
+      if (side === 'start' || side === 'left') {
+        return endResult.replace(/^\s*/, '');
+      }
+
+      if (side === 'end' || side === 'right') {
+        return endResult.replace(/\s*$/, '');
+      }
+
+      throw new Error('Side not supported: ' + side);
+    }
+  };
+};
+
+exports["default"] = trimResultTransformer;

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

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../../../_virtual/index2.cjs');
+var path$1 = require('node:path');
+require('../../../path-type@4.0.0/node_modules/path-type/index.cjs');
+var index$1 = require('../../../../../_virtual/index6.cjs');
+
+const path = path$1;
+const pathType = index$1.__exports;
+
+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, '**')];
+};
+
+index.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
+};
+
+index.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
+};
+
+exports["default"] = index.dirGlob.exports;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/index.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./managers/tasks.cjs');
+require('./managers/patterns.cjs');
+require('./providers/async.cjs');
+require('./providers/stream.cjs');
+require('./providers/sync.cjs');
+require('./settings.cjs');
+require('./utils/index.cjs');
+var tasks = require('../../../../../../_virtual/tasks.cjs');
+var patterns = require('../../../../../../_virtual/patterns.cjs');
+var async = require('../../../../../../_virtual/async.cjs');
+var stream = require('../../../../../../_virtual/stream.cjs');
+var sync = require('../../../../../../_virtual/sync.cjs');
+var settings = require('../../../../../../_virtual/settings.cjs');
+var index = require('../../../../../../_virtual/index5.cjs');
+
+const taskManager = tasks.__exports;
+const patternManager = patterns.__exports;
+const async_1 = async.__exports;
+const stream_1 = stream.__exports;
+const sync_1 = sync.__exports;
+const settings_1 = settings.__exports;
+const utils = index.__exports;
+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) {
+    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 = patternManager.transform([].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;
+})(FastGlob || (FastGlob = {}));
+function getWorks(source, _Provider, options) {
+    const patterns = patternManager.transform([].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');
+    }
+}
+var out = FastGlob;
+
+exports["default"] = out;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/managers/patterns.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var patterns = require('../../../../../../../_virtual/patterns.cjs');
+
+Object.defineProperty(patterns.__exports, "__esModule", { value: true });
+patterns.__exports.removeDuplicateSlashes = patterns.__exports.transform = void 0;
+/**
+ * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+ * The latter is due to the presence of the device path at the beginning of the UNC path.
+ * @todo rewrite to negative lookbehind with the next major release.
+ */
+const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+function transform(patterns) {
+    return patterns.map((pattern) => removeDuplicateSlashes(pattern));
+}
+patterns.__exports.transform = transform;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE, '/');
+}
+patterns.__exports.removeDuplicateSlashes = removeDuplicateSlashes;
+
+exports["default"] = patterns.__exports;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/managers/tasks.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tasks = require('../../../../../../../_virtual/tasks.cjs');
+require('../utils/index.cjs');
+var index = require('../../../../../../../_virtual/index5.cjs');
+
+Object.defineProperty(tasks.__exports, "__esModule", { value: true });
+tasks.__exports.convertPatternGroupToTask = tasks.__exports.convertPatternGroupsToTasks = tasks.__exports.groupPatternsByBaseDirectory = tasks.__exports.getNegativePatternsAsPositive = tasks.__exports.getPositivePatterns = tasks.__exports.convertPatternsToTasks = tasks.__exports.generate = void 0;
+const utils = index.__exports;
+function generate(patterns, settings) {
+    const positivePatterns = getPositivePatterns(patterns);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.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.__exports.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 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.__exports.convertPatternsToTasks = convertPatternsToTasks;
+function getPositivePatterns(patterns) {
+    return utils.pattern.getPositivePatterns(patterns);
+}
+tasks.__exports.getPositivePatterns = getPositivePatterns;
+function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map(utils.pattern.convertToPositivePattern);
+    return positive;
+}
+tasks.__exports.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.__exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map((base) => {
+        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+}
+tasks.__exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+        dynamic,
+        positive,
+        negative,
+        base,
+        patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+    };
+}
+tasks.__exports.convertPatternGroupToTask = convertPatternGroupToTask;
+
+exports["default"] = tasks.__exports;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/async.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var async = require('../../../../../../../_virtual/async.cjs');
+require('../readers/stream.cjs');
+require('./provider.cjs');
+var stream = require('../../../../../../../_virtual/stream2.cjs');
+var provider = require('../../../../../../../_virtual/provider.cjs');
+
+Object.defineProperty(async.__exports, "__esModule", { value: true });
+const stream_1 = stream.__exports;
+const provider_1 = provider.__exports;
+class ProviderAsync extends provider_1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new stream_1.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = [];
+        return new Promise((resolve, reject) => {
+            const stream = this.api(root, task, options);
+            stream.once('error', reject);
+            stream.on('data', (entry) => entries.push(options.transform(entry)));
+            stream.once('end', () => resolve(entries));
+        });
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+async.__exports.default = ProviderAsync;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/filters/deep.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var deep = require('../../../../../../../../_virtual/deep.cjs');
+require('../../utils/index.cjs');
+require('../matchers/partial.cjs');
+var index = require('../../../../../../../../_virtual/index5.cjs');
+var partial = require('../../../../../../../../_virtual/partial.cjs');
+
+Object.defineProperty(deep.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+const partial_1 = partial.__exports;
+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.__exports.default = DeepFilter;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/filters/entry.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var entry = require('../../../../../../../../_virtual/entry.cjs');
+require('../../utils/index.cjs');
+var index = require('../../../../../../../../_virtual/index5.cjs');
+
+Object.defineProperty(entry.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+class EntryFilter {
+    constructor(_settings, _micromatchOptions) {
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this.index = new Map();
+    }
+    getFilter(positive, negative) {
+        const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+        const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
+        return (entry) => this._filter(entry, positiveRe, negativeRe);
+    }
+    _filter(entry, positiveRe, negativeRe) {
+        if (this._settings.unique && this._isDuplicateEntry(entry)) {
+            return false;
+        }
+        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+            return false;
+        }
+        if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {
+            return false;
+        }
+        const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
+        const isMatched = this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);
+        if (this._settings.unique && isMatched) {
+            this._createIndexRecord(entry);
+        }
+        return isMatched;
+    }
+    _isDuplicateEntry(entry) {
+        return this.index.has(entry.path);
+    }
+    _createIndexRecord(entry) {
+        this.index.set(entry.path, undefined);
+    }
+    _onlyFileFilter(entry) {
+        return this._settings.onlyFiles && !entry.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry) {
+        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+    }
+    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
+        if (!this._settings.absolute) {
+            return false;
+        }
+        const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
+        return utils.pattern.matchAny(fullpath, patternsRe);
+    }
+    /**
+     * First, just trying to apply patterns to the path.
+     * Second, trying to apply patterns to the path with final slash.
+     */
+    _isMatchToPatterns(entryPath, patternsRe) {
+        const filepath = utils.path.removeLeadingDotSegment(entryPath);
+        return utils.pattern.matchAny(filepath, patternsRe) || utils.pattern.matchAny(filepath + '/', patternsRe);
+    }
+}
+entry.__exports.default = EntryFilter;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/filters/error.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var error = require('../../../../../../../../_virtual/error.cjs');
+require('../../utils/index.cjs');
+var index = require('../../../../../../../../_virtual/index5.cjs');
+
+Object.defineProperty(error.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+class ErrorFilter {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getFilter() {
+        return (error) => this._isNonFatalError(error);
+    }
+    _isNonFatalError(error) {
+        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+    }
+}
+error.__exports.default = ErrorFilter;

package/build/cjs/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/matchers/matcher.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var matcher = require('../../../../../../../../_virtual/matcher.cjs');
+require('../../utils/index.cjs');
+var index = require('../../../../../../../../_virtual/index5.cjs');
+
+Object.defineProperty(matcher.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+        this._patterns = _patterns;
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this._storage = [];
+        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) {
+            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.__exports.default = Matcher;