@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_node-chunks/globby-OEMHPBFY.js

@@ -0,0 +1,2884 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  require_micromatch
+} from "./chunk-QEQLR22M.js";
+import {
+  toPath
+} from "./chunk-BXVYT7SB.js";
+import {
+  slash
+} from "./chunk-DC7DKR5K.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-CXRU72ET.js";
+
+// ../../node_modules/fast-glob/out/utils/array.js
+var require_array = __commonJS({
+  "../../node_modules/fast-glob/out/utils/array.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.splitWhen = exports.flatten = void 0;
+    function flatten(items) {
+      return items.reduce((collection, item) => [].concat(collection, item), []);
+    }
+    exports.flatten = flatten;
+    function splitWhen(items, predicate) {
+      let result = [[]], groupIndex = 0;
+      for (let item of items)
+        predicate(item) ? (groupIndex++, result[groupIndex] = []) : result[groupIndex].push(item);
+      return result;
+    }
+    exports.splitWhen = splitWhen;
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/errno.js
+var require_errno = __commonJS({
+  "../../node_modules/fast-glob/out/utils/errno.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.isEnoentCodeError = void 0;
+    function isEnoentCodeError(error) {
+      return error.code === "ENOENT";
+    }
+    exports.isEnoentCodeError = isEnoentCodeError;
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/fs.js
+var require_fs = __commonJS({
+  "../../node_modules/fast-glob/out/utils/fs.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.createDirentFromStats = void 0;
+    var DirentFromStats = class {
+      constructor(name, stats) {
+        this.name = name, this.isBlockDevice = stats.isBlockDevice.bind(stats), this.isCharacterDevice = stats.isCharacterDevice.bind(stats), this.isDirectory = stats.isDirectory.bind(stats), this.isFIFO = stats.isFIFO.bind(stats), this.isFile = stats.isFile.bind(stats), this.isSocket = stats.isSocket.bind(stats), this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+      }
+    };
+    function createDirentFromStats(name, stats) {
+      return new DirentFromStats(name, stats);
+    }
+    exports.createDirentFromStats = createDirentFromStats;
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/path.js
+var require_path = __commonJS({
+  "../../node_modules/fast-glob/out/utils/path.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
+    var os = __require("os"), path2 = __require("path"), IS_WINDOWS_PLATFORM = os.platform() === "win32", LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2, POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g, WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g, DOS_DEVICE_PATH_RE = /^\\\\([.?])/, WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
+    function unixify(filepath) {
+      return filepath.replace(/\\/g, "/");
+    }
+    exports.unixify = unixify;
+    function makeAbsolute(cwd, filepath) {
+      return path2.resolve(cwd, filepath);
+    }
+    exports.makeAbsolute = makeAbsolute;
+    function removeLeadingDotSegment(entry) {
+      if (entry.charAt(0) === ".") {
+        let secondCharactery = entry.charAt(1);
+        if (secondCharactery === "/" || secondCharactery === "\\")
+          return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+      }
+      return entry;
+    }
+    exports.removeLeadingDotSegment = removeLeadingDotSegment;
+    exports.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+    function escapeWindowsPath(pattern) {
+      return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
+    }
+    exports.escapeWindowsPath = escapeWindowsPath;
+    function escapePosixPath(pattern) {
+      return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
+    }
+    exports.escapePosixPath = escapePosixPath;
+    exports.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+    function convertWindowsPathToPattern(filepath) {
+      return escapeWindowsPath(filepath).replace(DOS_DEVICE_PATH_RE, "//$1").replace(WINDOWS_BACKSLASHES_RE, "/");
+    }
+    exports.convertWindowsPathToPattern = convertWindowsPathToPattern;
+    function convertPosixPathToPattern(filepath) {
+      return escapePosixPath(filepath);
+    }
+    exports.convertPosixPathToPattern = convertPosixPathToPattern;
+  }
+});
+
+// ../../node_modules/is-extglob/index.js
+var require_is_extglob = __commonJS({
+  "../../node_modules/is-extglob/index.js"(exports, module) {
+    module.exports = function(str) {
+      if (typeof str != "string" || str === "")
+        return !1;
+      for (var match; match = /(\\).|([@?!+*]\(.*\))/g.exec(str); ) {
+        if (match[2]) return !0;
+        str = str.slice(match.index + match[0].length);
+      }
+      return !1;
+    };
+  }
+});
+
+// ../../node_modules/is-glob/index.js
+var require_is_glob = __commonJS({
+  "../../node_modules/is-glob/index.js"(exports, module) {
+    var isExtglob = require_is_extglob(), chars = { "{": "}", "(": ")", "[": "]" }, strictCheck = function(str) {
+      if (str[0] === "!")
+        return !0;
+      for (var index = 0, pipeIndex = -2, closeSquareIndex = -2, closeCurlyIndex = -2, closeParenIndex = -2, backSlashIndex = -2; index < str.length; ) {
+        if (str[index] === "*" || str[index + 1] === "?" && /[\].+)]/.test(str[index]) || closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]" && (closeSquareIndex < index && (closeSquareIndex = str.indexOf("]", index)), closeSquareIndex > index && (backSlashIndex === -1 || backSlashIndex > closeSquareIndex || (backSlashIndex = str.indexOf("\\", index), backSlashIndex === -1 || backSlashIndex > closeSquareIndex))) || closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}" && (closeCurlyIndex = str.indexOf("}", index), closeCurlyIndex > index && (backSlashIndex = str.indexOf("\\", index), backSlashIndex === -1 || backSlashIndex > closeCurlyIndex)) || closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")" && (closeParenIndex = str.indexOf(")", index), closeParenIndex > index && (backSlashIndex = str.indexOf("\\", index), backSlashIndex === -1 || backSlashIndex > closeParenIndex)) || pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|" && (pipeIndex < index && (pipeIndex = str.indexOf("|", index)), pipeIndex !== -1 && str[pipeIndex + 1] !== ")" && (closeParenIndex = str.indexOf(")", pipeIndex), closeParenIndex > pipeIndex && (backSlashIndex = str.indexOf("\\", pipeIndex), backSlashIndex === -1 || backSlashIndex > closeParenIndex))))
+          return !0;
+        if (str[index] === "\\") {
+          var open = str[index + 1];
+          index += 2;
+          var close = chars[open];
+          if (close) {
+            var n = str.indexOf(close, index);
+            n !== -1 && (index = n + 1);
+          }
+          if (str[index] === "!")
+            return !0;
+        } else
+          index++;
+      }
+      return !1;
+    }, relaxedCheck = function(str) {
+      if (str[0] === "!")
+        return !0;
+      for (var index = 0; index < str.length; ) {
+        if (/[*?{}()[\]]/.test(str[index]))
+          return !0;
+        if (str[index] === "\\") {
+          var open = str[index + 1];
+          index += 2;
+          var close = chars[open];
+          if (close) {
+            var n = str.indexOf(close, index);
+            n !== -1 && (index = n + 1);
+          }
+          if (str[index] === "!")
+            return !0;
+        } else
+          index++;
+      }
+      return !1;
+    };
+    module.exports = function(str, options) {
+      if (typeof str != "string" || str === "")
+        return !1;
+      if (isExtglob(str))
+        return !0;
+      var check = strictCheck;
+      return options && options.strict === !1 && (check = relaxedCheck), check(str);
+    };
+  }
+});
+
+// ../../node_modules/glob-parent/index.js
+var require_glob_parent = __commonJS({
+  "../../node_modules/glob-parent/index.js"(exports, module) {
+    "use strict";
+    var isGlob = require_is_glob(), pathPosixDirname = __require("path").posix.dirname, isWin32 = __require("os").platform() === "win32", slash2 = "/", backslash = /\\/g, enclosure = /[\{\[].*[\}\]]$/, globby2 = /(^|[^\\])([\{\[]|\([^\)]+$)/, escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+    module.exports = function(str, opts) {
+      var options = Object.assign({ flipBackslashes: !0 }, opts);
+      options.flipBackslashes && isWin32 && str.indexOf(slash2) < 0 && (str = str.replace(backslash, slash2)), enclosure.test(str) && (str += slash2), str += "a";
+      do
+        str = pathPosixDirname(str);
+      while (isGlob(str) || globby2.test(str));
+      return str.replace(escaped, "$1");
+    };
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/pattern.js
+var require_pattern = __commonJS({
+  "../../node_modules/fast-glob/out/utils/pattern.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.isAbsolute = exports.partitionAbsoluteAndRelative = exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
+    var path2 = __require("path"), globParent = require_glob_parent(), micromatch = require_micromatch(), GLOBSTAR = "**", ESCAPE_SYMBOL = "\\", COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/, REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/, REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/, GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/, BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./, DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+    function isStaticPattern(pattern, options = {}) {
+      return !isDynamicPattern2(pattern, options);
+    }
+    exports.isStaticPattern = isStaticPattern;
+    function isDynamicPattern2(pattern, options = {}) {
+      return pattern === "" ? !1 : !!(options.caseSensitiveMatch === !1 || pattern.includes(ESCAPE_SYMBOL) || COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern) || options.extglob !== !1 && GLOB_EXTENSION_SYMBOLS_RE.test(pattern) || options.braceExpansion !== !1 && hasBraceExpansion(pattern));
+    }
+    exports.isDynamicPattern = isDynamicPattern2;
+    function hasBraceExpansion(pattern) {
+      let openingBraceIndex = pattern.indexOf("{");
+      if (openingBraceIndex === -1)
+        return !1;
+      let closingBraceIndex = pattern.indexOf("}", openingBraceIndex + 1);
+      if (closingBraceIndex === -1)
+        return !1;
+      let braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+      return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+    }
+    function convertToPositivePattern(pattern) {
+      return isNegativePattern2(pattern) ? pattern.slice(1) : pattern;
+    }
+    exports.convertToPositivePattern = convertToPositivePattern;
+    function convertToNegativePattern(pattern) {
+      return "!" + pattern;
+    }
+    exports.convertToNegativePattern = convertToNegativePattern;
+    function isNegativePattern2(pattern) {
+      return pattern.startsWith("!") && pattern[1] !== "(";
+    }
+    exports.isNegativePattern = isNegativePattern2;
+    function isPositivePattern(pattern) {
+      return !isNegativePattern2(pattern);
+    }
+    exports.isPositivePattern = isPositivePattern;
+    function getNegativePatterns(patterns) {
+      return patterns.filter(isNegativePattern2);
+    }
+    exports.getNegativePatterns = getNegativePatterns;
+    function getPositivePatterns(patterns) {
+      return patterns.filter(isPositivePattern);
+    }
+    exports.getPositivePatterns = getPositivePatterns;
+    function getPatternsInsideCurrentDirectory(patterns) {
+      return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
+    }
+    exports.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+    function getPatternsOutsideCurrentDirectory(patterns) {
+      return patterns.filter(isPatternRelatedToParentDirectory);
+    }
+    exports.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+    function isPatternRelatedToParentDirectory(pattern) {
+      return pattern.startsWith("..") || pattern.startsWith("./..");
+    }
+    exports.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+    function getBaseDirectory(pattern) {
+      return globParent(pattern, { flipBackslashes: !1 });
+    }
+    exports.getBaseDirectory = getBaseDirectory;
+    function hasGlobStar(pattern) {
+      return pattern.includes(GLOBSTAR);
+    }
+    exports.hasGlobStar = hasGlobStar;
+    function endsWithSlashGlobStar(pattern) {
+      return pattern.endsWith("/" + GLOBSTAR);
+    }
+    exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
+    function isAffectDepthOfReadingPattern(pattern) {
+      let basename = path2.basename(pattern);
+      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+    }
+    exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+    function expandPatternsWithBraceExpansion(patterns) {
+      return patterns.reduce((collection, pattern) => collection.concat(expandBraceExpansion(pattern)), []);
+    }
+    exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+    function expandBraceExpansion(pattern) {
+      let patterns = micromatch.braces(pattern, { expand: !0, nodupes: !0, keepEscaping: !0 });
+      return patterns.sort((a, b) => a.length - b.length), patterns.filter((pattern2) => pattern2 !== "");
+    }
+    exports.expandBraceExpansion = expandBraceExpansion;
+    function getPatternParts(pattern, options) {
+      let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: !0 }));
+      return parts.length === 0 && (parts = [pattern]), parts[0].startsWith("/") && (parts[0] = parts[0].slice(1), parts.unshift("")), parts;
+    }
+    exports.getPatternParts = getPatternParts;
+    function makeRe(pattern, options) {
+      return micromatch.makeRe(pattern, options);
+    }
+    exports.makeRe = makeRe;
+    function convertPatternsToRe(patterns, options) {
+      return patterns.map((pattern) => makeRe(pattern, options));
+    }
+    exports.convertPatternsToRe = convertPatternsToRe;
+    function matchAny(entry, patternsRe) {
+      return patternsRe.some((patternRe) => patternRe.test(entry));
+    }
+    exports.matchAny = matchAny;
+    function removeDuplicateSlashes(pattern) {
+      return pattern.replace(DOUBLE_SLASH_RE, "/");
+    }
+    exports.removeDuplicateSlashes = removeDuplicateSlashes;
+    function partitionAbsoluteAndRelative(patterns) {
+      let absolute = [], relative = [];
+      for (let pattern of patterns)
+        isAbsolute(pattern) ? absolute.push(pattern) : relative.push(pattern);
+      return [absolute, relative];
+    }
+    exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
+    function isAbsolute(pattern) {
+      return path2.isAbsolute(pattern);
+    }
+    exports.isAbsolute = isAbsolute;
+  }
+});
+
+// ../../node_modules/merge2/index.js
+var require_merge2 = __commonJS({
+  "../../node_modules/merge2/index.js"(exports, module) {
+    "use strict";
+    var Stream = __require("stream"), PassThrough = Stream.PassThrough, slice = Array.prototype.slice;
+    module.exports = merge2;
+    function merge2() {
+      let streamsQueue = [], args = slice.call(arguments), merging = !1, options = args[args.length - 1];
+      options && !Array.isArray(options) && options.pipe == null ? args.pop() : options = {};
+      let doEnd = options.end !== !1, doPipeError = options.pipeError === !0;
+      options.objectMode == null && (options.objectMode = !0), options.highWaterMark == null && (options.highWaterMark = 64 * 1024);
+      let mergedStream = PassThrough(options);
+      function addStream() {
+        for (let i = 0, len = arguments.length; i < len; i++)
+          streamsQueue.push(pauseStreams(arguments[i], options));
+        return mergeStream(), this;
+      }
+      function mergeStream() {
+        if (merging)
+          return;
+        merging = !0;
+        let streams = streamsQueue.shift();
+        if (!streams) {
+          process.nextTick(endStream2);
+          return;
+        }
+        Array.isArray(streams) || (streams = [streams]);
+        let pipesCount = streams.length + 1;
+        function next() {
+          --pipesCount > 0 || (merging = !1, mergeStream());
+        }
+        function pipe(stream) {
+          function onend() {
+            stream.removeListener("merge2UnpipeEnd", onend), stream.removeListener("end", onend), doPipeError && stream.removeListener("error", onerror), next();
+          }
+          function onerror(err) {
+            mergedStream.emit("error", err);
+          }
+          if (stream._readableState.endEmitted)
+            return next();
+          stream.on("merge2UnpipeEnd", onend), stream.on("end", onend), doPipeError && stream.on("error", onerror), stream.pipe(mergedStream, { end: !1 }), stream.resume();
+        }
+        for (let i = 0; i < streams.length; i++)
+          pipe(streams[i]);
+        next();
+      }
+      function endStream2() {
+        merging = !1, mergedStream.emit("queueDrain"), doEnd && mergedStream.end();
+      }
+      return mergedStream.setMaxListeners(0), mergedStream.add = addStream, mergedStream.on("unpipe", function(stream) {
+        stream.emit("merge2UnpipeEnd");
+      }), args.length && addStream.apply(null, args), mergedStream;
+    }
+    function pauseStreams(streams, options) {
+      if (Array.isArray(streams))
+        for (let i = 0, len = streams.length; i < len; i++)
+          streams[i] = pauseStreams(streams[i], options);
+      else {
+        if (!streams._readableState && streams.pipe && (streams = streams.pipe(PassThrough(options))), !streams._readableState || !streams.pause || !streams.pipe)
+          throw new Error("Only readable stream can be merged.");
+        streams.pause();
+      }
+      return streams;
+    }
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/stream.js
+var require_stream = __commonJS({
+  "../../node_modules/fast-glob/out/utils/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.merge = void 0;
+    var merge2 = require_merge2();
+    function merge(streams) {
+      let mergedStream = merge2(streams);
+      return streams.forEach((stream) => {
+        stream.once("error", (error) => mergedStream.emit("error", error));
+      }), mergedStream.once("close", () => propagateCloseEventToSources(streams)), mergedStream.once("end", () => propagateCloseEventToSources(streams)), mergedStream;
+    }
+    exports.merge = merge;
+    function propagateCloseEventToSources(streams) {
+      streams.forEach((stream) => stream.emit("close"));
+    }
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/string.js
+var require_string = __commonJS({
+  "../../node_modules/fast-glob/out/utils/string.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.isEmpty = exports.isString = void 0;
+    function isString(input) {
+      return typeof input == "string";
+    }
+    exports.isString = isString;
+    function isEmpty(input) {
+      return input === "";
+    }
+    exports.isEmpty = isEmpty;
+  }
+});
+
+// ../../node_modules/fast-glob/out/utils/index.js
+var require_utils = __commonJS({
+  "../../node_modules/fast-glob/out/utils/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
+    var array = require_array();
+    exports.array = array;
+    var errno = require_errno();
+    exports.errno = errno;
+    var fs4 = require_fs();
+    exports.fs = fs4;
+    var path2 = require_path();
+    exports.path = path2;
+    var pattern = require_pattern();
+    exports.pattern = pattern;
+    var stream = require_stream();
+    exports.stream = stream;
+    var string = require_string();
+    exports.string = string;
+  }
+});
+
+// ../../node_modules/fast-glob/out/managers/tasks.js
+var require_tasks = __commonJS({
+  "../../node_modules/fast-glob/out/managers/tasks.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
+    var utils = require_utils();
+    function generate(input, settings) {
+      let patterns = processPatterns(input, settings), ignore = processPatterns(settings.ignore, settings), positivePatterns = getPositivePatterns(patterns), negativePatterns = getNegativePatternsAsPositive(patterns, ignore), staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings)), dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings)), staticTasks = convertPatternsToTasks(
+        staticPatterns,
+        negativePatterns,
+        /* dynamic */
+        !1
+      ), dynamicTasks = convertPatternsToTasks(
+        dynamicPatterns,
+        negativePatterns,
+        /* dynamic */
+        !0
+      );
+      return staticTasks.concat(dynamicTasks);
+    }
+    exports.generate = generate;
+    function processPatterns(input, settings) {
+      let patterns = input;
+      return settings.braceExpansion && (patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns)), settings.baseNameMatch && (patterns = patterns.map((pattern) => pattern.includes("/") ? pattern : `**/${pattern}`)), patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
+    }
+    function convertPatternsToTasks(positive, negative, dynamic) {
+      let tasks = [], patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive), patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive), outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory), insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+      return tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic)), "." in insideCurrentDirectoryGroup ? tasks.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic)) : tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic)), tasks;
+    }
+    exports.convertPatternsToTasks = convertPatternsToTasks;
+    function getPositivePatterns(patterns) {
+      return utils.pattern.getPositivePatterns(patterns);
+    }
+    exports.getPositivePatterns = getPositivePatterns;
+    function getNegativePatternsAsPositive(patterns, ignore) {
+      return utils.pattern.getNegativePatterns(patterns).concat(ignore).map(utils.pattern.convertToPositivePattern);
+    }
+    exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+    function groupPatternsByBaseDirectory(patterns) {
+      let group = {};
+      return patterns.reduce((collection, pattern) => {
+        let base = utils.pattern.getBaseDirectory(pattern);
+        return base in collection ? collection[base].push(pattern) : collection[base] = [pattern], collection;
+      }, group);
+    }
+    exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+    function convertPatternGroupsToTasks(positive, negative, dynamic) {
+      return Object.keys(positive).map((base) => convertPatternGroupToTask(base, positive[base], negative, dynamic));
+    }
+    exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+    function convertPatternGroupToTask(base, positive, negative, dynamic) {
+      return {
+        dynamic,
+        positive,
+        negative,
+        base,
+        patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+      };
+    }
+    exports.convertPatternGroupToTask = convertPatternGroupToTask;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.stat/out/providers/async.js
+var require_async = __commonJS({
+  "../../node_modules/@nodelib/fs.stat/out/providers/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.read = void 0;
+    function read(path2, settings, callback) {
+      settings.fs.lstat(path2, (lstatError, lstat) => {
+        if (lstatError !== null) {
+          callFailureCallback(callback, lstatError);
+          return;
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+          callSuccessCallback(callback, lstat);
+          return;
+        }
+        settings.fs.stat(path2, (statError, stat) => {
+          if (statError !== null) {
+            if (settings.throwErrorOnBrokenSymbolicLink) {
+              callFailureCallback(callback, statError);
+              return;
+            }
+            callSuccessCallback(callback, lstat);
+            return;
+          }
+          settings.markSymbolicLink && (stat.isSymbolicLink = () => !0), callSuccessCallback(callback, stat);
+        });
+      });
+    }
+    exports.read = read;
+    function callFailureCallback(callback, error) {
+      callback(error);
+    }
+    function callSuccessCallback(callback, result) {
+      callback(null, result);
+    }
+  }
+});
+
+// ../../node_modules/@nodelib/fs.stat/out/providers/sync.js
+var require_sync = __commonJS({
+  "../../node_modules/@nodelib/fs.stat/out/providers/sync.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.read = void 0;
+    function read(path2, settings) {
+      let lstat = settings.fs.lstatSync(path2);
+      if (!lstat.isSymbolicLink() || !settings.followSymbolicLink)
+        return lstat;
+      try {
+        let stat = settings.fs.statSync(path2);
+        return settings.markSymbolicLink && (stat.isSymbolicLink = () => !0), stat;
+      } catch (error) {
+        if (!settings.throwErrorOnBrokenSymbolicLink)
+          return lstat;
+        throw error;
+      }
+    }
+    exports.read = read;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.stat/out/adapters/fs.js
+var require_fs2 = __commonJS({
+  "../../node_modules/@nodelib/fs.stat/out/adapters/fs.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+    var fs4 = __require("fs");
+    exports.FILE_SYSTEM_ADAPTER = {
+      lstat: fs4.lstat,
+      stat: fs4.stat,
+      lstatSync: fs4.lstatSync,
+      statSync: fs4.statSync
+    };
+    function createFileSystemAdapter(fsMethods) {
+      return fsMethods === void 0 ? exports.FILE_SYSTEM_ADAPTER : Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+    }
+    exports.createFileSystemAdapter = createFileSystemAdapter;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.stat/out/settings.js
+var require_settings = __commonJS({
+  "../../node_modules/@nodelib/fs.stat/out/settings.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var fs4 = require_fs2(), Settings = class {
+      constructor(_options = {}) {
+        this._options = _options, this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, !0), this.fs = fs4.createFileSystemAdapter(this._options.fs), this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, !1), this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, !0);
+      }
+      _getValue(option, value) {
+        return option ?? value;
+      }
+    };
+    exports.default = Settings;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.stat/out/index.js
+var require_out = __commonJS({
+  "../../node_modules/@nodelib/fs.stat/out/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.statSync = exports.stat = exports.Settings = void 0;
+    var async = require_async(), sync = require_sync(), settings_1 = require_settings();
+    exports.Settings = settings_1.default;
+    function stat(path2, optionsOrSettingsOrCallback, callback) {
+      if (typeof optionsOrSettingsOrCallback == "function") {
+        async.read(path2, getSettings(), optionsOrSettingsOrCallback);
+        return;
+      }
+      async.read(path2, getSettings(optionsOrSettingsOrCallback), callback);
+    }
+    exports.stat = stat;
+    function statSync(path2, optionsOrSettings) {
+      let settings = getSettings(optionsOrSettings);
+      return sync.read(path2, settings);
+    }
+    exports.statSync = statSync;
+    function getSettings(settingsOrOptions = {}) {
+      return settingsOrOptions instanceof settings_1.default ? settingsOrOptions : new settings_1.default(settingsOrOptions);
+    }
+  }
+});
+
+// ../../node_modules/queue-microtask/index.js
+var require_queue_microtask = __commonJS({
+  "../../node_modules/queue-microtask/index.js"(exports, module) {
+    var promise;
+    module.exports = typeof queueMicrotask == "function" ? queueMicrotask.bind(typeof window < "u" ? window : global) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
+      throw err;
+    }, 0));
+  }
+});
+
+// ../../node_modules/run-parallel/index.js
+var require_run_parallel = __commonJS({
+  "../../node_modules/run-parallel/index.js"(exports, module) {
+    module.exports = runParallel;
+    var queueMicrotask2 = require_queue_microtask();
+    function runParallel(tasks, cb) {
+      let results, pending, keys, isSync = !0;
+      Array.isArray(tasks) ? (results = [], pending = tasks.length) : (keys = Object.keys(tasks), results = {}, pending = keys.length);
+      function done(err) {
+        function end() {
+          cb && cb(err, results), cb = null;
+        }
+        isSync ? queueMicrotask2(end) : end();
+      }
+      function each(i, err, result) {
+        results[i] = result, (--pending === 0 || err) && done(err);
+      }
+      pending ? keys ? keys.forEach(function(key) {
+        tasks[key](function(err, result) {
+          each(key, err, result);
+        });
+      }) : tasks.forEach(function(task, i) {
+        task(function(err, result) {
+          each(i, err, result);
+        });
+      }) : done(null), isSync = !1;
+    }
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+    var NODE_PROCESS_VERSION_PARTS = process.versions.node.split(".");
+    if (NODE_PROCESS_VERSION_PARTS[0] === void 0 || NODE_PROCESS_VERSION_PARTS[1] === void 0)
+      throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+    var MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10), MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10), SUPPORTED_MAJOR_VERSION = 10, SUPPORTED_MINOR_VERSION = 10, IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION, IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+    exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/utils/fs.js
+var require_fs3 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/utils/fs.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.createDirentFromStats = void 0;
+    var DirentFromStats = class {
+      constructor(name, stats) {
+        this.name = name, this.isBlockDevice = stats.isBlockDevice.bind(stats), this.isCharacterDevice = stats.isCharacterDevice.bind(stats), this.isDirectory = stats.isDirectory.bind(stats), this.isFIFO = stats.isFIFO.bind(stats), this.isFile = stats.isFile.bind(stats), this.isSocket = stats.isSocket.bind(stats), this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+      }
+    };
+    function createDirentFromStats(name, stats) {
+      return new DirentFromStats(name, stats);
+    }
+    exports.createDirentFromStats = createDirentFromStats;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/utils/index.js
+var require_utils2 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/utils/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.fs = void 0;
+    var fs4 = require_fs3();
+    exports.fs = fs4;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/providers/common.js
+var require_common = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/providers/common.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.joinPathSegments = void 0;
+    function joinPathSegments(a, b, separator) {
+      return a.endsWith(separator) ? a + b : a + separator + b;
+    }
+    exports.joinPathSegments = joinPathSegments;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/providers/async.js
+var require_async2 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/providers/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
+    var fsStat = require_out(), rpl = require_run_parallel(), constants_1 = require_constants(), utils = require_utils2(), common = require_common();
+    function read(directory, settings, callback) {
+      if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        readdirWithFileTypes(directory, settings, callback);
+        return;
+      }
+      readdir(directory, settings, callback);
+    }
+    exports.read = read;
+    function readdirWithFileTypes(directory, settings, callback) {
+      settings.fs.readdir(directory, { withFileTypes: !0 }, (readdirError, dirents) => {
+        if (readdirError !== null) {
+          callFailureCallback(callback, readdirError);
+          return;
+        }
+        let entries = dirents.map((dirent) => ({
+          dirent,
+          name: dirent.name,
+          path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        }));
+        if (!settings.followSymbolicLinks) {
+          callSuccessCallback(callback, entries);
+          return;
+        }
+        let tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks, (rplError, rplEntries) => {
+          if (rplError !== null) {
+            callFailureCallback(callback, rplError);
+            return;
+          }
+          callSuccessCallback(callback, rplEntries);
+        });
+      });
+    }
+    exports.readdirWithFileTypes = readdirWithFileTypes;
+    function makeRplTaskEntry(entry, settings) {
+      return (done) => {
+        if (!entry.dirent.isSymbolicLink()) {
+          done(null, entry);
+          return;
+        }
+        settings.fs.stat(entry.path, (statError, stats) => {
+          if (statError !== null) {
+            if (settings.throwErrorOnBrokenSymbolicLink) {
+              done(statError);
+              return;
+            }
+            done(null, entry);
+            return;
+          }
+          entry.dirent = utils.fs.createDirentFromStats(entry.name, stats), done(null, entry);
+        });
+      };
+    }
+    function readdir(directory, settings, callback) {
+      settings.fs.readdir(directory, (readdirError, names) => {
+        if (readdirError !== null) {
+          callFailureCallback(callback, readdirError);
+          return;
+        }
+        let tasks = names.map((name) => {
+          let path2 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+          return (done) => {
+            fsStat.stat(path2, settings.fsStatSettings, (error, stats) => {
+              if (error !== null) {
+                done(error);
+                return;
+              }
+              let entry = {
+                name,
+                path: path2,
+                dirent: utils.fs.createDirentFromStats(name, stats)
+              };
+              settings.stats && (entry.stats = stats), done(null, entry);
+            });
+          };
+        });
+        rpl(tasks, (rplError, entries) => {
+          if (rplError !== null) {
+            callFailureCallback(callback, rplError);
+            return;
+          }
+          callSuccessCallback(callback, entries);
+        });
+      });
+    }
+    exports.readdir = readdir;
+    function callFailureCallback(callback, error) {
+      callback(error);
+    }
+    function callSuccessCallback(callback, result) {
+      callback(null, result);
+    }
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/providers/sync.js
+var require_sync2 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/providers/sync.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.readdir = exports.readdirWithFileTypes = exports.read = void 0;
+    var fsStat = require_out(), constants_1 = require_constants(), utils = require_utils2(), common = require_common();
+    function read(directory, settings) {
+      return !settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES ? readdirWithFileTypes(directory, settings) : readdir(directory, settings);
+    }
+    exports.read = read;
+    function readdirWithFileTypes(directory, settings) {
+      return settings.fs.readdirSync(directory, { withFileTypes: !0 }).map((dirent) => {
+        let entry = {
+          dirent,
+          name: dirent.name,
+          path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks)
+          try {
+            let stats = settings.fs.statSync(entry.path);
+            entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+          } catch (error) {
+            if (settings.throwErrorOnBrokenSymbolicLink)
+              throw error;
+          }
+        return entry;
+      });
+    }
+    exports.readdirWithFileTypes = readdirWithFileTypes;
+    function readdir(directory, settings) {
+      return settings.fs.readdirSync(directory).map((name) => {
+        let entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator), stats = fsStat.statSync(entryPath, settings.fsStatSettings), entry = {
+          name,
+          path: entryPath,
+          dirent: utils.fs.createDirentFromStats(name, stats)
+        };
+        return settings.stats && (entry.stats = stats), entry;
+      });
+    }
+    exports.readdir = readdir;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/adapters/fs.js
+var require_fs4 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/adapters/fs.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+    var fs4 = __require("fs");
+    exports.FILE_SYSTEM_ADAPTER = {
+      lstat: fs4.lstat,
+      stat: fs4.stat,
+      lstatSync: fs4.lstatSync,
+      statSync: fs4.statSync,
+      readdir: fs4.readdir,
+      readdirSync: fs4.readdirSync
+    };
+    function createFileSystemAdapter(fsMethods) {
+      return fsMethods === void 0 ? exports.FILE_SYSTEM_ADAPTER : Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+    }
+    exports.createFileSystemAdapter = createFileSystemAdapter;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/settings.js
+var require_settings2 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/settings.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var path2 = __require("path"), fsStat = require_out(), fs4 = require_fs4(), Settings = class {
+      constructor(_options = {}) {
+        this._options = _options, this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, !1), this.fs = fs4.createFileSystemAdapter(this._options.fs), this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path2.sep), this.stats = this._getValue(this._options.stats, !1), this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, !0), this.fsStatSettings = new fsStat.Settings({
+          followSymbolicLink: this.followSymbolicLinks,
+          fs: this.fs,
+          throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+      }
+      _getValue(option, value) {
+        return option ?? value;
+      }
+    };
+    exports.default = Settings;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.scandir/out/index.js
+var require_out2 = __commonJS({
+  "../../node_modules/@nodelib/fs.scandir/out/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Settings = exports.scandirSync = exports.scandir = void 0;
+    var async = require_async2(), sync = require_sync2(), settings_1 = require_settings2();
+    exports.Settings = settings_1.default;
+    function scandir(path2, optionsOrSettingsOrCallback, callback) {
+      if (typeof optionsOrSettingsOrCallback == "function") {
+        async.read(path2, getSettings(), optionsOrSettingsOrCallback);
+        return;
+      }
+      async.read(path2, getSettings(optionsOrSettingsOrCallback), callback);
+    }
+    exports.scandir = scandir;
+    function scandirSync(path2, optionsOrSettings) {
+      let settings = getSettings(optionsOrSettings);
+      return sync.read(path2, settings);
+    }
+    exports.scandirSync = scandirSync;
+    function getSettings(settingsOrOptions = {}) {
+      return settingsOrOptions instanceof settings_1.default ? settingsOrOptions : new settings_1.default(settingsOrOptions);
+    }
+  }
+});
+
+// ../../node_modules/reusify/reusify.js
+var require_reusify = __commonJS({
+  "../../node_modules/reusify/reusify.js"(exports, module) {
+    "use strict";
+    function reusify(Constructor) {
+      var head = new Constructor(), tail = head;
+      function get() {
+        var current = head;
+        return current.next ? head = current.next : (head = new Constructor(), tail = head), current.next = null, current;
+      }
+      function release(obj) {
+        tail.next = obj, tail = obj;
+      }
+      return {
+        get,
+        release
+      };
+    }
+    module.exports = reusify;
+  }
+});
+
+// ../../node_modules/fastq/queue.js
+var require_queue = __commonJS({
+  "../../node_modules/fastq/queue.js"(exports, module) {
+    "use strict";
+    var reusify = require_reusify();
+    function fastqueue(context, worker, _concurrency) {
+      if (typeof context == "function" && (_concurrency = worker, worker = context, context = null), !(_concurrency >= 1))
+        throw new Error("fastqueue concurrency must be equal to or greater than 1");
+      var cache = reusify(Task), queueHead = null, queueTail = null, _running = 0, errorHandler = null, self = {
+        push,
+        drain: noop2,
+        saturated: noop2,
+        pause,
+        paused: !1,
+        get concurrency() {
+          return _concurrency;
+        },
+        set concurrency(value) {
+          if (!(value >= 1))
+            throw new Error("fastqueue concurrency must be equal to or greater than 1");
+          if (_concurrency = value, !self.paused)
+            for (; queueHead && _running < _concurrency; )
+              _running++, release();
+        },
+        running,
+        resume,
+        idle,
+        length,
+        getQueue,
+        unshift,
+        empty: noop2,
+        kill,
+        killAndDrain,
+        error,
+        abort
+      };
+      return self;
+      function running() {
+        return _running;
+      }
+      function pause() {
+        self.paused = !0;
+      }
+      function length() {
+        for (var current = queueHead, counter = 0; current; )
+          current = current.next, counter++;
+        return counter;
+      }
+      function getQueue() {
+        for (var current = queueHead, tasks = []; current; )
+          tasks.push(current.value), current = current.next;
+        return tasks;
+      }
+      function resume() {
+        if (self.paused) {
+          if (self.paused = !1, queueHead === null) {
+            _running++, release();
+            return;
+          }
+          for (; queueHead && _running < _concurrency; )
+            _running++, release();
+        }
+      }
+      function idle() {
+        return _running === 0 && self.length() === 0;
+      }
+      function push(value, done) {
+        var current = cache.get();
+        current.context = context, current.release = release, current.value = value, current.callback = done || noop2, current.errorHandler = errorHandler, _running >= _concurrency || self.paused ? queueTail ? (queueTail.next = current, queueTail = current) : (queueHead = current, queueTail = current, self.saturated()) : (_running++, worker.call(context, current.value, current.worked));
+      }
+      function unshift(value, done) {
+        var current = cache.get();
+        current.context = context, current.release = release, current.value = value, current.callback = done || noop2, current.errorHandler = errorHandler, _running >= _concurrency || self.paused ? queueHead ? (current.next = queueHead, queueHead = current) : (queueHead = current, queueTail = current, self.saturated()) : (_running++, worker.call(context, current.value, current.worked));
+      }
+      function release(holder) {
+        holder && cache.release(holder);
+        var next = queueHead;
+        next && _running <= _concurrency ? self.paused ? _running-- : (queueTail === queueHead && (queueTail = null), queueHead = next.next, next.next = null, worker.call(context, next.value, next.worked), queueTail === null && self.empty()) : --_running === 0 && self.drain();
+      }
+      function kill() {
+        queueHead = null, queueTail = null, self.drain = noop2;
+      }
+      function killAndDrain() {
+        queueHead = null, queueTail = null, self.drain(), self.drain = noop2;
+      }
+      function abort() {
+        var current = queueHead;
+        for (queueHead = null, queueTail = null; current; ) {
+          var next = current.next, callback = current.callback, errorHandler2 = current.errorHandler, val = current.value, context2 = current.context;
+          current.value = null, current.callback = noop2, current.errorHandler = null, current.next = null, errorHandler2 && errorHandler2(new Error("abort"), val), callback.call(context2, new Error("abort")), cache.release(current), current = next;
+        }
+        self.drain = noop2;
+      }
+      function error(handler) {
+        errorHandler = handler;
+      }
+    }
+    function noop2() {
+    }
+    function Task() {
+      this.value = null, this.callback = noop2, this.next = null, this.release = noop2, this.context = null, this.errorHandler = null;
+      var self = this;
+      this.worked = function(err, result) {
+        var callback = self.callback, errorHandler = self.errorHandler, val = self.value;
+        self.value = null, self.callback = noop2, self.errorHandler && errorHandler(err, val), callback.call(self.context, err, result), self.release(self);
+      };
+    }
+    function queueAsPromised(context, worker, _concurrency) {
+      typeof context == "function" && (_concurrency = worker, worker = context, context = null);
+      function asyncWrapper(arg, cb) {
+        worker.call(this, arg).then(function(res) {
+          cb(null, res);
+        }, cb);
+      }
+      var queue = fastqueue(context, asyncWrapper, _concurrency), pushCb = queue.push, unshiftCb = queue.unshift;
+      return queue.push = push, queue.unshift = unshift, queue.drained = drained, queue;
+      function push(value) {
+        var p = new Promise(function(resolve, reject) {
+          pushCb(value, function(err, result) {
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve(result);
+          });
+        });
+        return p.catch(noop2), p;
+      }
+      function unshift(value) {
+        var p = new Promise(function(resolve, reject) {
+          unshiftCb(value, function(err, result) {
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve(result);
+          });
+        });
+        return p.catch(noop2), p;
+      }
+      function drained() {
+        var p = new Promise(function(resolve) {
+          process.nextTick(function() {
+            if (queue.idle())
+              resolve();
+            else {
+              var previousDrain = queue.drain;
+              queue.drain = function() {
+                typeof previousDrain == "function" && previousDrain(), resolve(), queue.drain = previousDrain;
+              };
+            }
+          });
+        });
+        return p;
+      }
+    }
+    module.exports = fastqueue;
+    module.exports.promise = queueAsPromised;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/readers/common.js
+var require_common2 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/readers/common.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.joinPathSegments = exports.replacePathSegmentSeparator = exports.isAppliedFilter = exports.isFatalError = void 0;
+    function isFatalError(settings, error) {
+      return settings.errorFilter === null ? !0 : !settings.errorFilter(error);
+    }
+    exports.isFatalError = isFatalError;
+    function isAppliedFilter(filter, value) {
+      return filter === null || filter(value);
+    }
+    exports.isAppliedFilter = isAppliedFilter;
+    function replacePathSegmentSeparator(filepath, separator) {
+      return filepath.split(/[/\\]/).join(separator);
+    }
+    exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
+    function joinPathSegments(a, b, separator) {
+      return a === "" ? b : a.endsWith(separator) ? a + b : a + separator + b;
+    }
+    exports.joinPathSegments = joinPathSegments;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/readers/reader.js
+var require_reader = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/readers/reader.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var common = require_common2(), Reader = class {
+      constructor(_root, _settings) {
+        this._root = _root, this._settings = _settings, this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+      }
+    };
+    exports.default = Reader;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/readers/async.js
+var require_async3 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/readers/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var events_1 = __require("events"), fsScandir = require_out2(), fastq = require_queue(), common = require_common2(), reader_1 = require_reader(), AsyncReader = class extends reader_1.default {
+      constructor(_root, _settings) {
+        super(_root, _settings), this._settings = _settings, this._scandir = fsScandir.scandir, this._emitter = new events_1.EventEmitter(), this._queue = fastq(this._worker.bind(this), this._settings.concurrency), this._isFatalError = !1, this._isDestroyed = !1, this._queue.drain = () => {
+          this._isFatalError || this._emitter.emit("end");
+        };
+      }
+      read() {
+        return this._isFatalError = !1, this._isDestroyed = !1, setImmediate(() => {
+          this._pushToQueue(this._root, this._settings.basePath);
+        }), this._emitter;
+      }
+      get isDestroyed() {
+        return this._isDestroyed;
+      }
+      destroy() {
+        if (this._isDestroyed)
+          throw new Error("The reader is already destroyed");
+        this._isDestroyed = !0, this._queue.killAndDrain();
+      }
+      onEntry(callback) {
+        this._emitter.on("entry", callback);
+      }
+      onError(callback) {
+        this._emitter.once("error", callback);
+      }
+      onEnd(callback) {
+        this._emitter.once("end", callback);
+      }
+      _pushToQueue(directory, base) {
+        let queueItem = { directory, base };
+        this._queue.push(queueItem, (error) => {
+          error !== null && this._handleError(error);
+        });
+      }
+      _worker(item, done) {
+        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
+          if (error !== null) {
+            done(error, void 0);
+            return;
+          }
+          for (let entry of entries)
+            this._handleEntry(entry, item.base);
+          done(null, void 0);
+        });
+      }
+      _handleError(error) {
+        this._isDestroyed || !common.isFatalError(this._settings, error) || (this._isFatalError = !0, this._isDestroyed = !0, this._emitter.emit("error", error));
+      }
+      _handleEntry(entry, base) {
+        if (this._isDestroyed || this._isFatalError)
+          return;
+        let fullpath = entry.path;
+        base !== void 0 && (entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator)), common.isAppliedFilter(this._settings.entryFilter, entry) && this._emitEntry(entry), entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry) && this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
+      }
+      _emitEntry(entry) {
+        this._emitter.emit("entry", entry);
+      }
+    };
+    exports.default = AsyncReader;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/providers/async.js
+var require_async4 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/providers/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var async_1 = require_async3(), AsyncProvider = class {
+      constructor(_root, _settings) {
+        this._root = _root, this._settings = _settings, this._reader = new async_1.default(this._root, this._settings), this._storage = [];
+      }
+      read(callback) {
+        this._reader.onError((error) => {
+          callFailureCallback(callback, error);
+        }), this._reader.onEntry((entry) => {
+          this._storage.push(entry);
+        }), this._reader.onEnd(() => {
+          callSuccessCallback(callback, this._storage);
+        }), this._reader.read();
+      }
+    };
+    exports.default = AsyncProvider;
+    function callFailureCallback(callback, error) {
+      callback(error);
+    }
+    function callSuccessCallback(callback, entries) {
+      callback(null, entries);
+    }
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/providers/stream.js
+var require_stream2 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/providers/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var stream_1 = __require("stream"), async_1 = require_async3(), StreamProvider = class {
+      constructor(_root, _settings) {
+        this._root = _root, this._settings = _settings, this._reader = new async_1.default(this._root, this._settings), this._stream = new stream_1.Readable({
+          objectMode: !0,
+          read: () => {
+          },
+          destroy: () => {
+            this._reader.isDestroyed || this._reader.destroy();
+          }
+        });
+      }
+      read() {
+        return this._reader.onError((error) => {
+          this._stream.emit("error", error);
+        }), this._reader.onEntry((entry) => {
+          this._stream.push(entry);
+        }), this._reader.onEnd(() => {
+          this._stream.push(null);
+        }), this._reader.read(), this._stream;
+      }
+    };
+    exports.default = StreamProvider;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/readers/sync.js
+var require_sync3 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/readers/sync.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var fsScandir = require_out2(), common = require_common2(), reader_1 = require_reader(), SyncReader = class extends reader_1.default {
+      constructor() {
+        super(...arguments), this._scandir = fsScandir.scandirSync, this._storage = [], this._queue = /* @__PURE__ */ new Set();
+      }
+      read() {
+        return this._pushToQueue(this._root, this._settings.basePath), this._handleQueue(), this._storage;
+      }
+      _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
+      }
+      _handleQueue() {
+        for (let item of this._queue.values())
+          this._handleDirectory(item.directory, item.base);
+      }
+      _handleDirectory(directory, base) {
+        try {
+          let entries = this._scandir(directory, this._settings.fsScandirSettings);
+          for (let entry of entries)
+            this._handleEntry(entry, base);
+        } catch (error) {
+          this._handleError(error);
+        }
+      }
+      _handleError(error) {
+        if (common.isFatalError(this._settings, error))
+          throw error;
+      }
+      _handleEntry(entry, base) {
+        let fullpath = entry.path;
+        base !== void 0 && (entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator)), common.isAppliedFilter(this._settings.entryFilter, entry) && this._pushToStorage(entry), entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry) && this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
+      }
+      _pushToStorage(entry) {
+        this._storage.push(entry);
+      }
+    };
+    exports.default = SyncReader;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/providers/sync.js
+var require_sync4 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/providers/sync.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var sync_1 = require_sync3(), SyncProvider = class {
+      constructor(_root, _settings) {
+        this._root = _root, this._settings = _settings, this._reader = new sync_1.default(this._root, this._settings);
+      }
+      read() {
+        return this._reader.read();
+      }
+    };
+    exports.default = SyncProvider;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/settings.js
+var require_settings3 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/settings.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var path2 = __require("path"), fsScandir = require_out2(), Settings = class {
+      constructor(_options = {}) {
+        this._options = _options, this.basePath = this._getValue(this._options.basePath, void 0), this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY), this.deepFilter = this._getValue(this._options.deepFilter, null), this.entryFilter = this._getValue(this._options.entryFilter, null), this.errorFilter = this._getValue(this._options.errorFilter, null), this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path2.sep), this.fsScandirSettings = new fsScandir.Settings({
+          followSymbolicLinks: this._options.followSymbolicLinks,
+          fs: this._options.fs,
+          pathSegmentSeparator: this._options.pathSegmentSeparator,
+          stats: this._options.stats,
+          throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+      }
+      _getValue(option, value) {
+        return option ?? value;
+      }
+    };
+    exports.default = Settings;
+  }
+});
+
+// ../../node_modules/@nodelib/fs.walk/out/index.js
+var require_out3 = __commonJS({
+  "../../node_modules/@nodelib/fs.walk/out/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Settings = exports.walkStream = exports.walkSync = exports.walk = void 0;
+    var async_1 = require_async4(), stream_1 = require_stream2(), sync_1 = require_sync4(), settings_1 = require_settings3();
+    exports.Settings = settings_1.default;
+    function walk(directory, optionsOrSettingsOrCallback, callback) {
+      if (typeof optionsOrSettingsOrCallback == "function") {
+        new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+        return;
+      }
+      new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+    }
+    exports.walk = walk;
+    function walkSync(directory, optionsOrSettings) {
+      let settings = getSettings(optionsOrSettings);
+      return new sync_1.default(directory, settings).read();
+    }
+    exports.walkSync = walkSync;
+    function walkStream(directory, optionsOrSettings) {
+      let settings = getSettings(optionsOrSettings);
+      return new stream_1.default(directory, settings).read();
+    }
+    exports.walkStream = walkStream;
+    function getSettings(settingsOrOptions = {}) {
+      return settingsOrOptions instanceof settings_1.default ? settingsOrOptions : new settings_1.default(settingsOrOptions);
+    }
+  }
+});
+
+// ../../node_modules/fast-glob/out/readers/reader.js
+var require_reader2 = __commonJS({
+  "../../node_modules/fast-glob/out/readers/reader.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var path2 = __require("path"), fsStat = require_out(), utils = require_utils(), Reader = class {
+      constructor(_settings) {
+        this._settings = _settings, this._fsStatSettings = new fsStat.Settings({
+          followSymbolicLink: this._settings.followSymbolicLinks,
+          fs: this._settings.fs,
+          throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+        });
+      }
+      _getFullEntryPath(filepath) {
+        return path2.resolve(this._settings.cwd, filepath);
+      }
+      _makeEntry(stats, pattern) {
+        let entry = {
+          name: pattern,
+          path: pattern,
+          dirent: utils.fs.createDirentFromStats(pattern, stats)
+        };
+        return this._settings.stats && (entry.stats = stats), entry;
+      }
+      _isFatalError(error) {
+        return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+      }
+    };
+    exports.default = Reader;
+  }
+});
+
+// ../../node_modules/fast-glob/out/readers/stream.js
+var require_stream3 = __commonJS({
+  "../../node_modules/fast-glob/out/readers/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var stream_1 = __require("stream"), fsStat = require_out(), fsWalk = require_out3(), reader_1 = require_reader2(), ReaderStream = class extends reader_1.default {
+      constructor() {
+        super(...arguments), this._walkStream = fsWalk.walkStream, this._stat = fsStat.stat;
+      }
+      dynamic(root, options) {
+        return this._walkStream(root, options);
+      }
+      static(patterns, options) {
+        let filepaths = patterns.map(this._getFullEntryPath, this), stream = new stream_1.PassThrough({ objectMode: !0 });
+        stream._write = (index, _enc, done) => this._getEntry(filepaths[index], patterns[index], options).then((entry) => {
+          entry !== null && options.entryFilter(entry) && stream.push(entry), index === filepaths.length - 1 && stream.end(), done();
+        }).catch(done);
+        for (let i = 0; i < filepaths.length; i++)
+          stream.write(i);
+        return stream;
+      }
+      _getEntry(filepath, pattern, options) {
+        return this._getStat(filepath).then((stats) => this._makeEntry(stats, pattern)).catch((error) => {
+          if (options.errorFilter(error))
+            return null;
+          throw error;
+        });
+      }
+      _getStat(filepath) {
+        return new Promise((resolve, reject) => {
+          this._stat(filepath, this._fsStatSettings, (error, stats) => error === null ? resolve(stats) : reject(error));
+        });
+      }
+    };
+    exports.default = ReaderStream;
+  }
+});
+
+// ../../node_modules/fast-glob/out/readers/async.js
+var require_async5 = __commonJS({
+  "../../node_modules/fast-glob/out/readers/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var fsWalk = require_out3(), reader_1 = require_reader2(), stream_1 = require_stream3(), ReaderAsync = class extends reader_1.default {
+      constructor() {
+        super(...arguments), this._walkAsync = fsWalk.walk, this._readerStream = new stream_1.default(this._settings);
+      }
+      dynamic(root, options) {
+        return new Promise((resolve, reject) => {
+          this._walkAsync(root, options, (error, entries) => {
+            error === null ? resolve(entries) : reject(error);
+          });
+        });
+      }
+      async static(patterns, options) {
+        let entries = [], stream = this._readerStream.static(patterns, options);
+        return new Promise((resolve, reject) => {
+          stream.once("error", reject), stream.on("data", (entry) => entries.push(entry)), stream.once("end", () => resolve(entries));
+        });
+      }
+    };
+    exports.default = ReaderAsync;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/matchers/matcher.js
+var require_matcher = __commonJS({
+  "../../node_modules/fast-glob/out/providers/matchers/matcher.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var utils = require_utils(), Matcher = class {
+      constructor(_patterns, _settings, _micromatchOptions) {
+        this._patterns = _patterns, this._settings = _settings, this._micromatchOptions = _micromatchOptions, this._storage = [], this._fillStorage();
+      }
+      _fillStorage() {
+        for (let pattern of this._patterns) {
+          let segments = this._getPatternSegments(pattern), sections = this._splitSegmentsIntoSections(segments);
+          this._storage.push({
+            complete: sections.length <= 1,
+            pattern,
+            segments,
+            sections
+          });
+        }
+      }
+      _getPatternSegments(pattern) {
+        return utils.pattern.getPatternParts(pattern, this._micromatchOptions).map((part) => utils.pattern.isDynamicPattern(part, this._settings) ? {
+          dynamic: !0,
+          pattern: part,
+          patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+        } : {
+          dynamic: !1,
+          pattern: part
+        });
+      }
+      _splitSegmentsIntoSections(segments) {
+        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+      }
+    };
+    exports.default = Matcher;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/matchers/partial.js
+var require_partial = __commonJS({
+  "../../node_modules/fast-glob/out/providers/matchers/partial.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var matcher_1 = require_matcher(), PartialMatcher = class extends matcher_1.default {
+      match(filepath) {
+        let parts = filepath.split("/"), levels = parts.length, patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+        for (let pattern of patterns) {
+          let section = pattern.sections[0];
+          if (!pattern.complete && levels > section.length || parts.every((part, index) => {
+            let segment = pattern.segments[index];
+            return !!(segment.dynamic && segment.patternRe.test(part) || !segment.dynamic && segment.pattern === part);
+          }))
+            return !0;
+        }
+        return !1;
+      }
+    };
+    exports.default = PartialMatcher;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/filters/deep.js
+var require_deep = __commonJS({
+  "../../node_modules/fast-glob/out/providers/filters/deep.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var utils = require_utils(), partial_1 = require_partial(), DeepFilter = class {
+      constructor(_settings, _micromatchOptions) {
+        this._settings = _settings, this._micromatchOptions = _micromatchOptions;
+      }
+      getFilter(basePath, positive, negative) {
+        let matcher = this._getMatcher(positive), 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) {
+        let affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+        return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+      }
+      _filter(basePath, entry, matcher, negativeRe) {
+        if (this._isSkippedByDeep(basePath, entry.path) || this._isSkippedSymbolicLink(entry))
+          return !1;
+        let filepath = utils.path.removeLeadingDotSegment(entry.path);
+        return this._isSkippedByPositivePatterns(filepath, matcher) ? !1 : this._isSkippedByNegativePatterns(filepath, negativeRe);
+      }
+      _isSkippedByDeep(basePath, entryPath) {
+        return this._settings.deep === 1 / 0 ? !1 : this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+      }
+      _getEntryLevel(basePath, entryPath) {
+        let entryPathDepth = entryPath.split("/").length;
+        if (basePath === "")
+          return entryPathDepth;
+        let 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);
+      }
+    };
+    exports.default = DeepFilter;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/filters/entry.js
+var require_entry = __commonJS({
+  "../../node_modules/fast-glob/out/providers/filters/entry.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var utils = require_utils(), EntryFilter = class {
+      constructor(_settings, _micromatchOptions) {
+        this._settings = _settings, this._micromatchOptions = _micromatchOptions, this.index = /* @__PURE__ */ new Map();
+      }
+      getFilter(positive, negative) {
+        let [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative), patterns = {
+          positive: {
+            all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
+          },
+          negative: {
+            absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: !0 })),
+            relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: !0 }))
+          }
+        };
+        return (entry) => this._filter(entry, patterns);
+      }
+      _filter(entry, patterns) {
+        let filepath = utils.path.removeLeadingDotSegment(entry.path);
+        if (this._settings.unique && this._isDuplicateEntry(filepath) || this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry))
+          return !1;
+        let isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
+        return this._settings.unique && isMatched && this._createIndexRecord(filepath), isMatched;
+      }
+      _isDuplicateEntry(filepath) {
+        return this.index.has(filepath);
+      }
+      _createIndexRecord(filepath) {
+        this.index.set(filepath, void 0);
+      }
+      _onlyFileFilter(entry) {
+        return this._settings.onlyFiles && !entry.dirent.isFile();
+      }
+      _onlyDirectoryFilter(entry) {
+        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+      }
+      _isMatchToPatternsSet(filepath, patterns, isDirectory2) {
+        return !(!this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory2) || this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory2) || this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory2));
+      }
+      _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory2) {
+        if (patternsRe.length === 0)
+          return !1;
+        let fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+        return this._isMatchToPatterns(fullpath, patternsRe, isDirectory2);
+      }
+      _isMatchToPatterns(filepath, patternsRe, isDirectory2) {
+        if (patternsRe.length === 0)
+          return !1;
+        let isMatched = utils.pattern.matchAny(filepath, patternsRe);
+        return !isMatched && isDirectory2 ? utils.pattern.matchAny(filepath + "/", patternsRe) : isMatched;
+      }
+    };
+    exports.default = EntryFilter;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/filters/error.js
+var require_error = __commonJS({
+  "../../node_modules/fast-glob/out/providers/filters/error.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var utils = require_utils(), ErrorFilter = class {
+      constructor(_settings) {
+        this._settings = _settings;
+      }
+      getFilter() {
+        return (error) => this._isNonFatalError(error);
+      }
+      _isNonFatalError(error) {
+        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+      }
+    };
+    exports.default = ErrorFilter;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/transformers/entry.js
+var require_entry2 = __commonJS({
+  "../../node_modules/fast-glob/out/providers/transformers/entry.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var utils = require_utils(), EntryTransformer = class {
+      constructor(_settings) {
+        this._settings = _settings;
+      }
+      getTransformer() {
+        return (entry) => this._transform(entry);
+      }
+      _transform(entry) {
+        let filepath = entry.path;
+        return this._settings.absolute && (filepath = utils.path.makeAbsolute(this._settings.cwd, filepath), filepath = utils.path.unixify(filepath)), this._settings.markDirectories && entry.dirent.isDirectory() && (filepath += "/"), this._settings.objectMode ? Object.assign(Object.assign({}, entry), { path: filepath }) : filepath;
+      }
+    };
+    exports.default = EntryTransformer;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/provider.js
+var require_provider = __commonJS({
+  "../../node_modules/fast-glob/out/providers/provider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var path2 = __require("path"), deep_1 = require_deep(), entry_1 = require_entry(), error_1 = require_error(), entry_2 = require_entry2(), Provider = class {
+      constructor(_settings) {
+        this._settings = _settings, this.errorFilter = new error_1.default(this._settings), this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions()), this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions()), this.entryTransformer = new entry_2.default(this._settings);
+      }
+      _getRootDirectory(task) {
+        return path2.resolve(this._settings.cwd, task.base);
+      }
+      _getReaderOptions(task) {
+        let basePath = task.base === "." ? "" : task.base;
+        return {
+          basePath,
+          pathSegmentSeparator: "/",
+          concurrency: this._settings.concurrency,
+          deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+          entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+          errorFilter: this.errorFilter.getFilter(),
+          followSymbolicLinks: this._settings.followSymbolicLinks,
+          fs: this._settings.fs,
+          stats: this._settings.stats,
+          throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+          transform: this.entryTransformer.getTransformer()
+        };
+      }
+      _getMicromatchOptions() {
+        return {
+          dot: this._settings.dot,
+          matchBase: this._settings.baseNameMatch,
+          nobrace: !this._settings.braceExpansion,
+          nocase: !this._settings.caseSensitiveMatch,
+          noext: !this._settings.extglob,
+          noglobstar: !this._settings.globstar,
+          posix: !0,
+          strictSlashes: !1
+        };
+      }
+    };
+    exports.default = Provider;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/async.js
+var require_async6 = __commonJS({
+  "../../node_modules/fast-glob/out/providers/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var async_1 = require_async5(), provider_1 = require_provider(), ProviderAsync = class extends provider_1.default {
+      constructor() {
+        super(...arguments), this._reader = new async_1.default(this._settings);
+      }
+      async read(task) {
+        let root = this._getRootDirectory(task), options = this._getReaderOptions(task);
+        return (await this.api(root, task, options)).map((entry) => options.transform(entry));
+      }
+      api(root, task, options) {
+        return task.dynamic ? this._reader.dynamic(root, options) : this._reader.static(task.patterns, options);
+      }
+    };
+    exports.default = ProviderAsync;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/stream.js
+var require_stream4 = __commonJS({
+  "../../node_modules/fast-glob/out/providers/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var stream_1 = __require("stream"), stream_2 = require_stream3(), provider_1 = require_provider(), ProviderStream = class extends provider_1.default {
+      constructor() {
+        super(...arguments), this._reader = new stream_2.default(this._settings);
+      }
+      read(task) {
+        let root = this._getRootDirectory(task), options = this._getReaderOptions(task), source = this.api(root, task, options), destination = new stream_1.Readable({ objectMode: !0, read: () => {
+        } });
+        return source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options.transform(entry))).once("end", () => destination.emit("end")), destination.once("close", () => source.destroy()), destination;
+      }
+      api(root, task, options) {
+        return task.dynamic ? this._reader.dynamic(root, options) : this._reader.static(task.patterns, options);
+      }
+    };
+    exports.default = ProviderStream;
+  }
+});
+
+// ../../node_modules/fast-glob/out/readers/sync.js
+var require_sync5 = __commonJS({
+  "../../node_modules/fast-glob/out/readers/sync.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var fsStat = require_out(), fsWalk = require_out3(), reader_1 = require_reader2(), ReaderSync = class extends reader_1.default {
+      constructor() {
+        super(...arguments), this._walkSync = fsWalk.walkSync, this._statSync = fsStat.statSync;
+      }
+      dynamic(root, options) {
+        return this._walkSync(root, options);
+      }
+      static(patterns, options) {
+        let entries = [];
+        for (let pattern of patterns) {
+          let filepath = this._getFullEntryPath(pattern), entry = this._getEntry(filepath, pattern, options);
+          entry === null || !options.entryFilter(entry) || entries.push(entry);
+        }
+        return entries;
+      }
+      _getEntry(filepath, pattern, options) {
+        try {
+          let stats = this._getStat(filepath);
+          return this._makeEntry(stats, pattern);
+        } catch (error) {
+          if (options.errorFilter(error))
+            return null;
+          throw error;
+        }
+      }
+      _getStat(filepath) {
+        return this._statSync(filepath, this._fsStatSettings);
+      }
+    };
+    exports.default = ReaderSync;
+  }
+});
+
+// ../../node_modules/fast-glob/out/providers/sync.js
+var require_sync6 = __commonJS({
+  "../../node_modules/fast-glob/out/providers/sync.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var sync_1 = require_sync5(), provider_1 = require_provider(), ProviderSync = class extends provider_1.default {
+      constructor() {
+        super(...arguments), this._reader = new sync_1.default(this._settings);
+      }
+      read(task) {
+        let root = this._getRootDirectory(task), options = this._getReaderOptions(task);
+        return this.api(root, task, options).map(options.transform);
+      }
+      api(root, task, options) {
+        return task.dynamic ? this._reader.dynamic(root, options) : this._reader.static(task.patterns, options);
+      }
+    };
+    exports.default = ProviderSync;
+  }
+});
+
+// ../../node_modules/fast-glob/out/settings.js
+var require_settings4 = __commonJS({
+  "../../node_modules/fast-glob/out/settings.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+    var fs4 = __require("fs"), os = __require("os"), CPU_COUNT = Math.max(os.cpus().length, 1);
+    exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+      lstat: fs4.lstat,
+      lstatSync: fs4.lstatSync,
+      stat: fs4.stat,
+      statSync: fs4.statSync,
+      readdir: fs4.readdir,
+      readdirSync: fs4.readdirSync
+    };
+    var Settings = class {
+      constructor(_options = {}) {
+        this._options = _options, this.absolute = this._getValue(this._options.absolute, !1), this.baseNameMatch = this._getValue(this._options.baseNameMatch, !1), this.braceExpansion = this._getValue(this._options.braceExpansion, !0), this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, !0), this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT), this.cwd = this._getValue(this._options.cwd, process.cwd()), this.deep = this._getValue(this._options.deep, 1 / 0), this.dot = this._getValue(this._options.dot, !1), this.extglob = this._getValue(this._options.extglob, !0), this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, !0), this.fs = this._getFileSystemMethods(this._options.fs), this.globstar = this._getValue(this._options.globstar, !0), this.ignore = this._getValue(this._options.ignore, []), this.markDirectories = this._getValue(this._options.markDirectories, !1), this.objectMode = this._getValue(this._options.objectMode, !1), this.onlyDirectories = this._getValue(this._options.onlyDirectories, !1), this.onlyFiles = this._getValue(this._options.onlyFiles, !0), this.stats = this._getValue(this._options.stats, !1), this.suppressErrors = this._getValue(this._options.suppressErrors, !1), this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, !1), this.unique = this._getValue(this._options.unique, !0), this.onlyDirectories && (this.onlyFiles = !1), this.stats && (this.objectMode = !0), this.ignore = [].concat(this.ignore);
+      }
+      _getValue(option, value) {
+        return option === void 0 ? value : option;
+      }
+      _getFileSystemMethods(methods = {}) {
+        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+      }
+    };
+    exports.default = Settings;
+  }
+});
+
+// ../../node_modules/fast-glob/out/index.js
+var require_out4 = __commonJS({
+  "../../node_modules/fast-glob/out/index.js"(exports, module) {
+    "use strict";
+    var taskManager = require_tasks(), async_1 = require_async6(), stream_1 = require_stream4(), sync_1 = require_sync6(), settings_1 = require_settings4(), utils = require_utils();
+    async function FastGlob(source, options) {
+      assertPatternsInput2(source);
+      let works = getWorks(source, async_1.default, options), result = await Promise.all(works);
+      return utils.array.flatten(result);
+    }
+    (function(FastGlob2) {
+      FastGlob2.glob = FastGlob2, FastGlob2.globSync = sync, FastGlob2.globStream = stream, FastGlob2.async = FastGlob2;
+      function sync(source, options) {
+        assertPatternsInput2(source);
+        let works = getWorks(source, sync_1.default, options);
+        return utils.array.flatten(works);
+      }
+      FastGlob2.sync = sync;
+      function stream(source, options) {
+        assertPatternsInput2(source);
+        let works = getWorks(source, stream_1.default, options);
+        return utils.stream.merge(works);
+      }
+      FastGlob2.stream = stream;
+      function generateTasks2(source, options) {
+        assertPatternsInput2(source);
+        let patterns = [].concat(source), settings = new settings_1.default(options);
+        return taskManager.generate(patterns, settings);
+      }
+      FastGlob2.generateTasks = generateTasks2;
+      function isDynamicPattern2(source, options) {
+        assertPatternsInput2(source);
+        let settings = new settings_1.default(options);
+        return utils.pattern.isDynamicPattern(source, settings);
+      }
+      FastGlob2.isDynamicPattern = isDynamicPattern2;
+      function escapePath(source) {
+        return assertPatternsInput2(source), utils.path.escape(source);
+      }
+      FastGlob2.escapePath = escapePath;
+      function convertPathToPattern2(source) {
+        return assertPatternsInput2(source), utils.path.convertPathToPattern(source);
+      }
+      FastGlob2.convertPathToPattern = convertPathToPattern2;
+      let posix;
+      (function(posix2) {
+        function escapePath2(source) {
+          return assertPatternsInput2(source), utils.path.escapePosixPath(source);
+        }
+        posix2.escapePath = escapePath2;
+        function convertPathToPattern3(source) {
+          return assertPatternsInput2(source), utils.path.convertPosixPathToPattern(source);
+        }
+        posix2.convertPathToPattern = convertPathToPattern3;
+      })(posix = FastGlob2.posix || (FastGlob2.posix = {}));
+      let win32;
+      (function(win322) {
+        function escapePath2(source) {
+          return assertPatternsInput2(source), utils.path.escapeWindowsPath(source);
+        }
+        win322.escapePath = escapePath2;
+        function convertPathToPattern3(source) {
+          return assertPatternsInput2(source), utils.path.convertWindowsPathToPattern(source);
+        }
+        win322.convertPathToPattern = convertPathToPattern3;
+      })(win32 = FastGlob2.win32 || (FastGlob2.win32 = {}));
+    })(FastGlob || (FastGlob = {}));
+    function getWorks(source, _Provider, options) {
+      let patterns = [].concat(source), settings = new settings_1.default(options), tasks = taskManager.generate(patterns, settings), provider = new _Provider(settings);
+      return tasks.map(provider.read, provider);
+    }
+    function assertPatternsInput2(input) {
+      if (![].concat(input).every((item) => utils.string.isString(item) && !utils.string.isEmpty(item)))
+        throw new TypeError("Patterns must be a string (non empty) or an array of strings");
+    }
+    module.exports = FastGlob;
+  }
+});
+
+// ../../node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0, EMPTY = "", SPACE = " ", ESCAPE = "\\", REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/, BOM = "\uFEFF", REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/, REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/, REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/, REGEX_SPLITALL_CRLF = /\r?\n/g, DOUBLE_SLASH = "//", SLASH_CODE = 47, DOT_CODE = 46, SLASH = "/", TMP_KEY_IGNORE = "node-ignore";
+    typeof Symbol < "u" && (TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore"));
+    var KEY_IGNORE = TMP_KEY_IGNORE, define = (object, key, value) => (Object.defineProperty(object, key, { value }), value), RETURN_FALSE = () => !1, cleanRangeBackSlash = (slashes) => {
+      let { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    }, POSIX_CLASSES = {
+      alnum: "0-9A-Za-z",
+      alpha: "A-Za-z",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1f\\x7f",
+      digit: "0-9",
+      graph: "!-.0-~",
+      lower: "a-z",
+      print: " -.0-~",
+      punct: "!-.:-@\\[-`{-~",
+      // git's `sane-ctype.h` classifies \v and \f as control, not space,
+      //   unlike C's `isspace`
+      space: " \\t\\n\\r",
+      upper: "A-Z",
+      xdigit: "0-9A-Fa-f"
+    }, CLASS_MEMBERS_TO_ESCAPE = "\\]^-[", escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char, NON_SLASH = "(?!\\/)", classSource = (negated, body) => {
+      if (negated)
+        return `[^\\/${body}]`;
+      let source = `[${body}]`;
+      return new RegExp(source).test("/") ? NON_SLASH + source : source;
+    }, scanBracket = (pattern, start) => {
+      let { length } = pattern, index = start + 1, negated = EMPTY, lead = pattern[index];
+      (lead === "!" || lead === "^") && (negated = "^", index++);
+      let body = EMPTY, prev = EMPTY;
+      for (; ; ) {
+        let char = pattern[index];
+        if (char === UNDEFINED)
+          return null;
+        if (char === ESCAPE) {
+          let escaped = pattern[index + 1];
+          if (escaped === UNDEFINED)
+            return null;
+          body += escapeMember(escaped), prev = escaped, index++;
+        } else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+          index++;
+          let to = pattern[index];
+          to === ESCAPE && (to = pattern[index += 1]), prev <= to && (body += `-${escapeMember(to)}`), prev = EMPTY;
+        } else if (char === "[" && pattern[index + 1] === ":") {
+          let nameStart = index + 2, end = nameStart;
+          for (; end < length && pattern[end] !== "]"; )
+            end++;
+          if (end === length)
+            return null;
+          if (end > nameStart && pattern[end - 1] === ":") {
+            let expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+            if (expanded === UNDEFINED)
+              return null;
+            body += expanded, prev = EMPTY, index = end;
+          } else
+            body += escapeMember("["), prev = "[", index = nameStart - 2;
+        } else
+          body += escapeMember(char), prev = char;
+        if (index++, pattern[index] === "]")
+          return {
+            end: index,
+            source: classSource(negated, body)
+          };
+      }
+    }, NEVER_MATCH = "[]", PLACEHOLDER = "\0", REGEX_RESTORE_PLACEHOLDER = new RegExp(
+      `${PLACEHOLDER}(\\d+)${PLACEHOLDER}`,
+      "g"
+    ), TRAILING_WILDCARD = "\uE000", TRAILING_DOUBLESTAR = "\uE001", extractBrackets = (pattern) => {
+      let sources = [], hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`, { length } = pattern, out = EMPTY, index = 0;
+      for (; index < length; ) {
+        let char = pattern[index];
+        if (char === ESCAPE) {
+          let escaped = pattern[index + 1];
+          escaped === UNDEFINED || escaped === SLASH && index + 2 === length ? out += hold(NEVER_MATCH) : escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE ? out += pattern.slice(index, index + 2) : out += hold(
+            REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped
+          ), index += 2;
+        } else if (char === PLACEHOLDER)
+          out += hold(`[${PLACEHOLDER}]`), index++;
+        else if (char === "[") {
+          let scanned = scanBracket(pattern, index);
+          scanned === null ? (out += hold(NEVER_MATCH), index = length) : (out += hold(scanned.source), index = scanned.end + 1);
+        } else
+          out += char, index++;
+      }
+      return {
+        source: out,
+        sources
+      };
+    }, DIRECT = null, REGEX_INNER_SLASH = /\/(?!$)/, REPLACERS = [
+      // Replace (\ ) with ' '
+      // Only a space: an escaped tab or other whitespace is already a literal by
+      //   the time it reaches here, and a bare tab must be left as one, not turned
+      //   into a space.
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        // A run of backslashes is taken whole, from its first one, so no match
+        //   ever starts again inside it -- `(\\+?) ` did, which made a long run
+        //   quadratic.
+        /(\\+)( ?)/g,
+        (_, run, space) => space ? run.slice(0, run.length - run.length % 2) + SPACE : run,
+        ESCAPE + SPACE
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]",
+        "?"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^",
+        SLASH
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/",
+        SLASH
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*(?:\\\*\\\*\\\/)+/,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?",
+        "*"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        DIRECT,
+        (source, pattern) => !source || source[0] === "^" ? source : (REGEX_INNER_SLASH.test(pattern) ? "^" : "(?:^|\\/)") + source
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
+        "*"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          let unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        },
+        "*"
+      ],
+      // trailing wildcard, held apart from a literal star
+      [
+        // The step above leaves a trailing `*` alone, so a single `\*` is all that
+        //   can be left at the end here. Whether it is a wildcard or a literal
+        //   turns on the backslashes the user put in front of it: the escaper has
+        //   since doubled every one, so what stands here is those `2N` doubled
+        //   backslashes and then the star's own escape. An even number of the
+        //   original `N` leaves the star unescaped -- a wildcard -- and an odd
+        //   number escapes it -- a literal. This runs while the two are still
+        //   distinct, before the unescape steps below collapse the literal onto
+        //   the very `\*` a wildcard leaves behind.
+        /(^|[^\\])((?:\\\\)*)\\\*$/,
+        (match, p1, p2) => (
+          // `p2` holds the doubled user backslashes; half of them is `N`.
+          p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match
+        ),
+        "*"
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE,
+        ESCAPE + ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE,
+        ESCAPE + ESCAPE
+      ],
+      [
+        // Every real bracket expression -- POSIX classes included -- has already
+        //   been held aside by `extractBrackets`, so the only `[` left in the
+        //   pattern is an escaped, literal one.
+        // `\` is escaped by step 3
+        /\\\[([^\]/]*?)(\\*)($|\])/g,
+        // '\\[bar]' -> '\\\\[bar\\]'
+        (match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+        "["
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        DIRECT,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (source) => {
+          let last = source[source.length - 1];
+          return !last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR ? source : last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+        }
+      ]
+    ], REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/, MODE_IGNORE = "regex", MODE_CHECK_IGNORE = "checkRegex", UNDERSCORE = "_", replaceTrailingWildcard = (_, p1) => `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`, REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/, replaceTrailingDoublestar = () => ".+(?=$|\\/$)", WILDCARD = "[^\\/]*", separatorAfter = (run, at) => {
+      let separator = EMPTY;
+      for (let index = at + 1; index < run.length && !run[index].wildcard; index++)
+        separator += run[index].single;
+      return separator;
+    }, pinWildcards = (source) => {
+      if (source.indexOf(WILDCARD) < 0)
+        return source;
+      let tokens = [], { length } = source, index = 0;
+      for (; index < length; ) {
+        let char = source[index];
+        if (source.startsWith(WILDCARD, index))
+          tokens.push({ wildcard: !0 }), index += WILDCARD.length;
+        else if (char === "[") {
+          let end = index + 1;
+          for (source[end] === "^" && end++, source[end] === "]" && end++; end < length && source[end] !== "]"; )
+            end += source[end] === ESCAPE ? 2 : 1;
+          end++, tokens.push({ single: source.slice(index, end) }), index = end;
+        } else if (char === ESCAPE)
+          tokens.push({ single: source.slice(index, index + 2) }), index += 2;
+        else if (char === "(") {
+          let depth = 0, end = index;
+          do
+            source[end] === ESCAPE ? end++ : source[end] === "(" ? depth++ : source[end] === ")" && depth--, end++;
+          while (end < length && depth > 0);
+          "*+?".indexOf(source[end]) >= 0 && end++, tokens.push({ boundary: source.slice(index, end) }), index = end;
+        } else char === "^" || char === "$" ? (tokens.push({ boundary: char }), index++) : (tokens.push({ single: char }), index++);
+      }
+      let out = EMPTY, run = [], flush = () => {
+        let lastWildcard;
+        run.forEach((token, at) => {
+          token.wildcard && (lastWildcard = at);
+        }), run.forEach((token, at) => {
+          if (!token.wildcard) {
+            out += token.single;
+            return;
+          }
+          out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+        }), run = [];
+      };
+      return tokens.forEach((token) => {
+        if (token.boundary === void 0) {
+          run.push(token);
+          return;
+        }
+        flush(), out += token.boundary;
+      }), flush(), out;
+    }, makeRegexPrefix = (pattern) => {
+      let { source, sources } = extractBrackets(pattern), replaced = REPLACERS.reduce(
+        // A pass whose matcher finds nothing hands back the very string it was
+        //   given, so asking first costs a search and saves a rewrite. Ten of the
+        //   fifteen passes never fire for a typical .gitignore line, and between
+        //   them they were 45% of this chain.
+        (prev, [matcher, replacer, required]) => matcher === DIRECT ? replacer(prev, pattern) : required !== UNDEFINED && prev.indexOf(required) < 0 ? prev : matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev,
+        source
+      );
+      return sources.length ? replaced.replace(
+        REGEX_RESTORE_PLACEHOLDER,
+        (match, index) => sources[index]
+      ) : replaced;
+    }, checkSourceOf = (body, prefix) => {
+      body[body.length - 1] === SLASH && (prefix = makeRegexPrefix(body.slice(0, -1)));
+      let head = prefix.slice(0, -1), last = prefix[prefix.length - 1];
+      return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
+    }, matchesBasename = (body) => {
+      let index = body.indexOf(SLASH);
+      return index < 0 || index === body.length - 1;
+    }, basenameOf = (path2) => {
+      let end = path2.length - 1, index = path2.lastIndexOf(
+        SLASH,
+        path2[end] === SLASH ? end - 1 : end
+      );
+      return index < 0 ? path2 : path2.slice(index + 1);
+    }, parentOf = (path2) => {
+      if (path2.charCodeAt(0) === SLASH_CODE || path2.indexOf(DOUBLE_SLASH) >= 0) {
+        let slices = path2.split(SLASH).filter(Boolean);
+        return slices.pop(), slices.length ? slices.join(SLASH) + SLASH : EMPTY;
+      }
+      let end = path2.length - 1, cut = path2.lastIndexOf(
+        SLASH,
+        path2.charCodeAt(end) === SLASH_CODE ? end - 1 : end
+      );
+      return cut < 0 ? EMPTY : path2.slice(0, cut + 1);
+    }, isString = (subject) => typeof subject == "string", checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern), splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean), IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern, this.mark = mark, this.negative = negative, define(this, "body", body), define(this, "ignoreCase", ignoreCase), define(this, "regexPrefix", prefix);
+      }
+      // Worked out on first use and kept behind an own property, the way `regex`
+      //   caches itself in `_regex`. Deciding it in the constructor instead would
+      //   add a fourth `defineProperty` to every rule ever built, which cost 4% of
+      //   every compile -- including the compiles of rules that are never matched
+      //   against anything.
+      get _basenameOnly() {
+        return define(this, "_basenameOnly", matchesBasename(this.body));
+      }
+      get regex() {
+        let key = UNDERSCORE + MODE_IGNORE;
+        return this[key] ? this[key] : this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        let key = UNDERSCORE + MODE_CHECK_IGNORE;
+        return this[key] ? this[key] : this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        let str = pinWildcards(
+          mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix)
+        ), regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    }, isLineEnd = (char) => char === "\r" || char === `
+`, trimEnd = (body) => {
+      let end = body.length;
+      for (; end && isLineEnd(body[end - 1]); )
+        end--;
+      let lineEnd = end;
+      for (; end && body[end - 1] === SPACE; )
+        end--;
+      if (end === lineEnd)
+        return body.slice(0, end);
+      let backslashes = 0;
+      for (; backslashes < end && body[end - backslashes - 1] === ESCAPE; )
+        backslashes++;
+      return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+    }, createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+      if (body[0] === "#")
+        return;
+      let negative = !1;
+      body[0] === "!" && (negative = !0, body = body.slice(1));
+      let last = body[body.length - 1];
+      if ((last === SPACE || last === "\r" || last === `
+`) && (body = trimEnd(body)), !body)
+        return;
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      let regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    }, RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase, this._rules = [], this._basenameCount = 0;
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules), this._basenameCount += pattern._rules._basenameCount, this._added = !0;
+          return;
+        }
+        isString(pattern) && (pattern = {
+          pattern
+        });
+        let rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+        rule && (this._added = !0, this._rules.push(rule), matchesBasename(rule.body) && this._basenameCount++);
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        return this._added = !1, makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this), this._added && (this._literalRules = UNDEFINED), this._added;
+      }
+      // Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule
+      //   ending in a wildcard can match it (see `checkSourceOf`), so the rest
+      //   are left out once, rather than tested or compiled for every path.
+      testLiteral(path2) {
+        let rules = this._literalRules || (this._literalRules = this._rules.filter(
+          ({ body }) => body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === "*"
+        )), ignored = !1, unignored = !1, matchedRule;
+        for (let index = rules.length - 1; index >= 0; index--) {
+          let rule = rules[index];
+          if (rule.checkRegex.test(path2)) {
+            ignored = !rule.negative, unignored = rule.negative, matchedRule = rule.negative ? UNDEFINED : rule;
+            break;
+          }
+        }
+        let ret = {
+          ignored,
+          unignored
+        };
+        return matchedRule && (ret.rule = matchedRule), ret;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path2, checkUnignored, mode) {
+        let ignored = !1, unignored = !1, matchedRule, rules = this._rules, { length } = rules, shortcut = this._basenameCount * 2 >= length, basename = shortcut ? basenameOf(path2) : path2;
+        for (let index = 0; index < length; index++) {
+          let rule = rules[index], { negative } = rule;
+          !(unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) && rule[mode].test(
+            shortcut && rule._basenameOnly ? basename : path2
+          ) && (ignored = !negative, unignored = negative, matchedRule = negative ? UNDEFINED : rule);
+        }
+        let ret = {
+          ignored,
+          unignored
+        };
+        return matchedRule && (ret.rule = matchedRule), ret;
+      }
+    }, throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    }, checkPath = (path2, originalPath, doThrow) => isString(path2) ? path2 ? checkPath.isNotRelative(path2) ? doThrow(
+      `path should be a \`path.relative()\`d string, but got "${originalPath}"`,
+      RangeError
+    ) : !0 : doThrow("path must not be empty", TypeError) : doThrow(
+      `path must be a string, but got \`${originalPath}\``,
+      TypeError
+    ), isNotRelative = (path2) => {
+      let first = path2.charCodeAt(0);
+      if (first === SLASH_CODE)
+        return !0;
+      if (first !== DOT_CODE)
+        return !1;
+      if (path2.length === 1)
+        return !0;
+      let second = path2.charCodeAt(1);
+      return second === SLASH_CODE ? !0 : second !== DOT_CODE ? !1 : path2.length === 2 || path2.charCodeAt(2) === SLASH_CODE;
+    };
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = !0,
+        ignoreCase = ignorecase,
+        allowRelativePaths = !1
+      } = {}) {
+        define(this, KEY_IGNORE, !0), this._rules = new RuleManager(ignoreCase), this._strictPathCheck = !allowRelativePaths, this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null), this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        return this._rules.add(pattern) && this._initCache(), this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored) {
+        let path2 = originalPath && checkPath.convert(originalPath);
+        return checkPath(
+          path2,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        ), this._t(path2, cache, checkUnignored);
+      }
+      checkIgnore(path2) {
+        if (path2.charCodeAt(path2.length - 1) !== SLASH_CODE)
+          return this.test(path2);
+        let dir = this._t(path2, this._testCache, !0);
+        if (dir.ignored)
+          return dir;
+        let literal = this._rules.testLiteral(path2);
+        return literal.ignored || literal.unignored ? literal : dir;
+      }
+      _t(path2, cache, checkUnignored) {
+        if (path2 in cache)
+          return cache[path2];
+        let parentPath = parentOf(path2), parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+        return cache[path2] = parent && parent.ignored ? parent : this._rules.test(path2, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path2) {
+        return this._test(path2, this._ignoreCache, !1).ignored;
+      }
+      createFilter() {
+        return (path2) => !this.ignores(path2);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path2) {
+        return this._test(path2, this._testCache, !0);
+      }
+    }, factory = (options) => new Ignore(options), isPathValid = (path2) => checkPath(path2 && checkPath.convert(path2), path2, RETURN_FALSE), setupWindows = () => {
+      let makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      let REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path2) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path2) || isNotRelative(path2);
+    };
+    // Detect `process` so that it can run in browsers.
+    typeof process < "u" && process.platform === "win32" && setupWindows();
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// ../../node_modules/globby/index.js
+import process3 from "node:process";
+import fs3 from "node:fs";
+import nodePath from "node:path";
+
+// ../../node_modules/globby/node_modules/@sindresorhus/merge-streams/index.js
+import { on, once } from "node:events";
+import { PassThrough as PassThroughStream } from "node:stream";
+import { finished } from "node:stream/promises";
+function mergeStreams(streams) {
+  if (!Array.isArray(streams))
+    throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
+  for (let stream of streams)
+    validateStream(stream);
+  let objectMode = streams.some(({ readableObjectMode }) => readableObjectMode), highWaterMark = getHighWaterMark(streams, objectMode), passThroughStream = new MergedStream({
+    objectMode,
+    writableHighWaterMark: highWaterMark,
+    readableHighWaterMark: highWaterMark
+  });
+  for (let stream of streams)
+    passThroughStream.add(stream);
+  return streams.length === 0 && endStream(passThroughStream), passThroughStream;
+}
+var getHighWaterMark = (streams, objectMode) => {
+  if (streams.length === 0)
+    return 16384;
+  let highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
+  return Math.max(...highWaterMarks);
+}, MergedStream = class extends PassThroughStream {
+  #streams = /* @__PURE__ */ new Set([]);
+  #ended = /* @__PURE__ */ new Set([]);
+  #aborted = /* @__PURE__ */ new Set([]);
+  #onFinished;
+  add(stream) {
+    validateStream(stream), !this.#streams.has(stream) && (this.#streams.add(stream), this.#onFinished ??= onMergedStreamFinished(this, this.#streams), endWhenStreamsDone({
+      passThroughStream: this,
+      stream,
+      streams: this.#streams,
+      ended: this.#ended,
+      aborted: this.#aborted,
+      onFinished: this.#onFinished
+    }), stream.pipe(this, { end: !1 }));
+  }
+  remove(stream) {
+    return validateStream(stream), this.#streams.has(stream) ? (stream.unpipe(this), !0) : !1;
+  }
+}, onMergedStreamFinished = async (passThroughStream, streams) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
+  let controller = new AbortController();
+  try {
+    await Promise.race([
+      onMergedStreamEnd(passThroughStream, controller),
+      onInputStreamsUnpipe(passThroughStream, streams, controller)
+    ]);
+  } finally {
+    controller.abort(), updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
+  }
+}, onMergedStreamEnd = async (passThroughStream, { signal }) => {
+  await finished(passThroughStream, { signal, cleanup: !0 });
+}, onInputStreamsUnpipe = async (passThroughStream, streams, { signal }) => {
+  for await (let [unpipedStream] of on(passThroughStream, "unpipe", { signal }))
+    streams.has(unpipedStream) && unpipedStream.emit(unpipeEvent);
+}, validateStream = (stream) => {
+  if (typeof stream?.pipe != "function")
+    throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
+}, endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, aborted, onFinished }) => {
+  updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
+  let controller = new AbortController();
+  try {
+    await Promise.race([
+      afterMergedStreamFinished(onFinished, stream),
+      onInputStreamEnd({ passThroughStream, stream, streams, ended, aborted, controller }),
+      onInputStreamUnpipe({ stream, streams, ended, aborted, controller })
+    ]);
+  } finally {
+    controller.abort(), updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
+  }
+  streams.size === ended.size + aborted.size && (ended.size === 0 && aborted.size > 0 ? abortStream(passThroughStream) : endStream(passThroughStream));
+}, isAbortError = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE", afterMergedStreamFinished = async (onFinished, stream) => {
+  try {
+    await onFinished, abortStream(stream);
+  } catch (error) {
+    isAbortError(error) ? abortStream(stream) : errorStream(stream, error);
+  }
+}, onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted, controller: { signal } }) => {
+  try {
+    await finished(stream, { signal, cleanup: !0, readable: !0, writable: !1 }), streams.has(stream) && ended.add(stream);
+  } catch (error) {
+    if (signal.aborted || !streams.has(stream))
+      return;
+    isAbortError(error) ? aborted.add(stream) : errorStream(passThroughStream, error);
+  }
+}, onInputStreamUnpipe = async ({ stream, streams, ended, aborted, controller: { signal } }) => {
+  await once(stream, unpipeEvent, { signal }), streams.delete(stream), ended.delete(stream), aborted.delete(stream);
+}, unpipeEvent = /* @__PURE__ */ Symbol("unpipe"), endStream = (stream) => {
+  stream.writable && stream.end();
+}, abortStream = (stream) => {
+  (stream.readable || stream.writable) && stream.destroy();
+}, errorStream = (stream, error) => {
+  stream.destroyed || (stream.once("error", noop), stream.destroy(error));
+}, noop = () => {
+}, updateMaxListeners = (passThroughStream, increment) => {
+  let maxListeners = passThroughStream.getMaxListeners();
+  maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY && passThroughStream.setMaxListeners(maxListeners + increment);
+}, PASSTHROUGH_LISTENERS_COUNT = 2, PASSTHROUGH_LISTENERS_PER_STREAM = 1;
+
+// ../../node_modules/globby/index.js
+var import_fast_glob2 = __toESM(require_out4(), 1);
+
+// ../../node_modules/path-type/index.js
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+async function isType(fsStatType, statsMethodName, filePath) {
+  if (typeof filePath != "string")
+    throw new TypeError(`Expected a string, got ${typeof filePath}`);
+  try {
+    return (await fsPromises[fsStatType](filePath))[statsMethodName]();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return !1;
+    throw error;
+  }
+}
+function isTypeSync(fsStatType, statsMethodName, filePath) {
+  if (typeof filePath != "string")
+    throw new TypeError(`Expected a string, got ${typeof filePath}`);
+  try {
+    return fs[fsStatType](filePath)[statsMethodName]();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return !1;
+    throw error;
+  }
+}
+var isFile = isType.bind(void 0, "stat", "isFile"), isDirectory = isType.bind(void 0, "stat", "isDirectory"), isSymlink = isType.bind(void 0, "lstat", "isSymbolicLink"), isFileSync = isTypeSync.bind(void 0, "statSync", "isFile"), isDirectorySync = isTypeSync.bind(void 0, "statSync", "isDirectory"), isSymlinkSync = isTypeSync.bind(void 0, "lstatSync", "isSymbolicLink");
+
+// ../../node_modules/globby/ignore.js
+var import_fast_glob = __toESM(require_out4(), 1), import_ignore = __toESM(require_ignore(), 1);
+import process2 from "node:process";
+import fs2 from "node:fs";
+import fsPromises2 from "node:fs/promises";
+import path from "node:path";
+
+// ../../node_modules/globby/utilities.js
+var isNegativePattern = (pattern) => pattern[0] === "!";
+
+// ../../node_modules/globby/ignore.js
+var defaultIgnoredDirectories = [
+  "**/node_modules",
+  "**/flow-typed",
+  "**/coverage",
+  "**/.git"
+], ignoreFilesGlobOptions = {
+  absolute: !0,
+  dot: !0
+}, GITIGNORE_FILES_PATTERN = "**/.gitignore", applyBaseToPattern = (pattern, base) => isNegativePattern(pattern) ? "!" + path.posix.join(base, pattern.slice(1)) : path.posix.join(base, pattern), parseIgnoreFile = (file, cwd) => {
+  let base = slash(path.relative(cwd, path.dirname(file.filePath)));
+  return file.content.split(/\r?\n/).filter((line) => line && !line.startsWith("#")).map((pattern) => applyBaseToPattern(pattern, base));
+}, toRelativePath = (fileOrDirectory, cwd) => {
+  if (cwd = slash(cwd), path.isAbsolute(fileOrDirectory)) {
+    if (slash(fileOrDirectory).startsWith(cwd))
+      return path.relative(cwd, fileOrDirectory);
+    throw new Error(`Path ${fileOrDirectory} is not in cwd ${cwd}`);
+  }
+  return fileOrDirectory;
+}, getIsIgnoredPredicate = (files, cwd) => {
+  let patterns = files.flatMap((file) => parseIgnoreFile(file, cwd)), ignores = (0, import_ignore.default)().add(patterns);
+  return (fileOrDirectory) => (fileOrDirectory = toPath(fileOrDirectory), fileOrDirectory = toRelativePath(fileOrDirectory, cwd), fileOrDirectory ? ignores.ignores(slash(fileOrDirectory)) : !1);
+}, normalizeOptions = (options = {}) => ({
+  cwd: toPath(options.cwd) ?? process2.cwd(),
+  suppressErrors: !!options.suppressErrors,
+  deep: typeof options.deep == "number" ? options.deep : Number.POSITIVE_INFINITY,
+  ignore: [...options.ignore ?? [], ...defaultIgnoredDirectories]
+}), isIgnoredByIgnoreFiles = async (patterns, options) => {
+  let { cwd, suppressErrors, deep, ignore } = normalizeOptions(options), paths = await (0, import_fast_glob.default)(patterns, {
+    cwd,
+    suppressErrors,
+    deep,
+    ignore,
+    ...ignoreFilesGlobOptions
+  }), files = await Promise.all(
+    paths.map(async (filePath) => ({
+      filePath,
+      content: await fsPromises2.readFile(filePath, "utf8")
+    }))
+  );
+  return getIsIgnoredPredicate(files, cwd);
+}, isIgnoredByIgnoreFilesSync = (patterns, options) => {
+  let { cwd, suppressErrors, deep, ignore } = normalizeOptions(options), files = import_fast_glob.default.sync(patterns, {
+    cwd,
+    suppressErrors,
+    deep,
+    ignore,
+    ...ignoreFilesGlobOptions
+  }).map((filePath) => ({
+    filePath,
+    content: fs2.readFileSync(filePath, "utf8")
+  }));
+  return getIsIgnoredPredicate(files, cwd);
+}, isGitIgnored = (options) => isIgnoredByIgnoreFiles(GITIGNORE_FILES_PATTERN, options), isGitIgnoredSync = (options) => isIgnoredByIgnoreFilesSync(GITIGNORE_FILES_PATTERN, options);
+
+// ../../node_modules/globby/index.js
+var assertPatternsInput = (patterns) => {
+  if (patterns.some((pattern) => typeof pattern != "string"))
+    throw new TypeError("Patterns must be a string or an array of strings");
+}, normalizePathForDirectoryGlob = (filePath, cwd) => {
+  let path2 = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
+  return nodePath.isAbsolute(path2) ? path2 : nodePath.join(cwd, path2);
+}, getDirectoryGlob = ({ directoryPath, files, extensions }) => {
+  let extensionGlob = extensions?.length > 0 ? `.${extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0]}` : "";
+  return files ? files.map((file) => nodePath.posix.join(directoryPath, `**/${nodePath.extname(file) ? file : `${file}${extensionGlob}`}`)) : [nodePath.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ""}`)];
+}, directoryToGlob = async (directoryPaths, {
+  cwd = process3.cwd(),
+  files,
+  extensions
+} = {}) => (await Promise.all(
+  directoryPaths.map(async (directoryPath) => await isDirectory(normalizePathForDirectoryGlob(directoryPath, cwd)) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath)
+)).flat(), directoryToGlobSync = (directoryPaths, {
+  cwd = process3.cwd(),
+  files,
+  extensions
+} = {}) => directoryPaths.flatMap((directoryPath) => isDirectorySync(normalizePathForDirectoryGlob(directoryPath, cwd)) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath), toPatternsArray = (patterns) => (patterns = [...new Set([patterns].flat())], assertPatternsInput(patterns), patterns), checkCwdOption = (cwd) => {
+  if (!cwd)
+    return;
+  let stat;
+  try {
+    stat = fs3.statSync(cwd);
+  } catch {
+    return;
+  }
+  if (!stat.isDirectory())
+    throw new Error("The `cwd` option must be a path to a directory");
+}, normalizeOptions2 = (options = {}) => (options = {
+  ...options,
+  ignore: options.ignore ?? [],
+  expandDirectories: options.expandDirectories ?? !0,
+  cwd: toPath(options.cwd)
+}, checkCwdOption(options.cwd), options), normalizeArguments = (function_) => async (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions2(options)), normalizeArgumentsSync = (function_) => (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions2(options)), getIgnoreFilesPatterns = (options) => {
+  let { ignoreFiles, gitignore } = options, patterns = ignoreFiles ? toPatternsArray(ignoreFiles) : [];
+  return gitignore && patterns.push(GITIGNORE_FILES_PATTERN), patterns;
+}, getFilter = async (options) => {
+  let ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+  return createFilterFunction(
+    ignoreFilesPatterns.length > 0 && await isIgnoredByIgnoreFiles(ignoreFilesPatterns, options)
+  );
+}, getFilterSync = (options) => {
+  let ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+  return createFilterFunction(
+    ignoreFilesPatterns.length > 0 && isIgnoredByIgnoreFilesSync(ignoreFilesPatterns, options)
+  );
+}, createFilterFunction = (isIgnored) => {
+  let seen = /* @__PURE__ */ new Set();
+  return (fastGlobResult) => {
+    let pathKey = nodePath.normalize(fastGlobResult.path ?? fastGlobResult);
+    return seen.has(pathKey) || isIgnored && isIgnored(pathKey) ? !1 : (seen.add(pathKey), !0);
+  };
+}, unionFastGlobResults = (results, filter) => results.flat().filter((fastGlobResult) => filter(fastGlobResult)), convertNegativePatterns = (patterns, options) => {
+  let tasks = [];
+  for (; patterns.length > 0; ) {
+    let index = patterns.findIndex((pattern) => isNegativePattern(pattern));
+    if (index === -1) {
+      tasks.push({ patterns, options });
+      break;
+    }
+    let ignorePattern = patterns[index].slice(1);
+    for (let task of tasks)
+      task.options.ignore.push(ignorePattern);
+    index !== 0 && tasks.push({
+      patterns: patterns.slice(0, index),
+      options: {
+        ...options,
+        ignore: [
+          ...options.ignore,
+          ignorePattern
+        ]
+      }
+    }), patterns = patterns.slice(index + 1);
+  }
+  return tasks;
+}, normalizeExpandDirectoriesOption = (options, cwd) => ({
+  ...cwd ? { cwd } : {},
+  ...Array.isArray(options) ? { files: options } : options
+}), generateTasks = async (patterns, options) => {
+  let globTasks = convertNegativePatterns(patterns, options), { cwd, expandDirectories } = options;
+  if (!expandDirectories)
+    return globTasks;
+  let directoryToGlobOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
+  return Promise.all(
+    globTasks.map(async (task) => {
+      let { patterns: patterns2, options: options2 } = task;
+      return [
+        patterns2,
+        options2.ignore
+      ] = await Promise.all([
+        directoryToGlob(patterns2, directoryToGlobOptions),
+        directoryToGlob(options2.ignore, { cwd })
+      ]), { patterns: patterns2, options: options2 };
+    })
+  );
+}, generateTasksSync = (patterns, options) => {
+  let globTasks = convertNegativePatterns(patterns, options), { cwd, expandDirectories } = options;
+  if (!expandDirectories)
+    return globTasks;
+  let directoryToGlobSyncOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
+  return globTasks.map((task) => {
+    let { patterns: patterns2, options: options2 } = task;
+    return patterns2 = directoryToGlobSync(patterns2, directoryToGlobSyncOptions), options2.ignore = directoryToGlobSync(options2.ignore, { cwd }), { patterns: patterns2, options: options2 };
+  });
+}, globby = normalizeArguments(async (patterns, options) => {
+  let [
+    tasks,
+    filter
+  ] = await Promise.all([
+    generateTasks(patterns, options),
+    getFilter(options)
+  ]), results = await Promise.all(tasks.map((task) => (0, import_fast_glob2.default)(task.patterns, task.options)));
+  return unionFastGlobResults(results, filter);
+}), globbySync = normalizeArgumentsSync((patterns, options) => {
+  let tasks = generateTasksSync(patterns, options), filter = getFilterSync(options), results = tasks.map((task) => import_fast_glob2.default.sync(task.patterns, task.options));
+  return unionFastGlobResults(results, filter);
+}), globbyStream = normalizeArgumentsSync((patterns, options) => {
+  let tasks = generateTasksSync(patterns, options), filter = getFilterSync(options), streams = tasks.map((task) => import_fast_glob2.default.stream(task.patterns, task.options));
+  return mergeStreams(streams).filter((fastGlobResult) => filter(fastGlobResult));
+}), isDynamicPattern = normalizeArgumentsSync(
+  (patterns, options) => patterns.some((pattern) => import_fast_glob2.default.isDynamicPattern(pattern, options))
+), generateGlobTasks = normalizeArguments(generateTasks), generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync), { convertPathToPattern } = import_fast_glob2.default;
+export {
+  convertPathToPattern,
+  generateGlobTasks,
+  generateGlobTasksSync,
+  globby,
+  globbyStream,
+  globbySync,
+  isDynamicPattern,
+  isGitIgnored,
+  isGitIgnoredSync,
+  isIgnoredByIgnoreFiles,
+  isIgnoredByIgnoreFilesSync
+};