@oclif/plugin-test-esbuild 0.5.121 → 0.5.123

package/dist/{chunk-HRNB5OEJ.js → chunk-5HENEZOV.js}

@@ -254,7 +254,7 @@ var require_package = __commonJS({
     module.exports = {
       name: "@oclif/core",
       description: "base library for oclif CLIs",
-      version: "4.10.2",
+      version: "4.10.3",
       author: "Salesforce",
       bugs: "https://github.com/oclif/core/issues",
       dependencies: {
@@ -288,7 +288,7 @@ var require_package = __commonJS({
         "@types/chai": "^4.3.16",
         "@types/chai-as-promised": "^7.1.8",
         "@types/clean-stack": "^2.1.1",
-        "@types/debug": "^4.1.10",
+        "@types/debug": "^4.1.13",
         "@types/ejs": "^3.1.5",
         "@types/indent-string": "^4.0.1",
         "@types/mocha": "^10.0.10",
@@ -1164,69 +1164,6 @@ var require_ejs = __commonJS({
   }
 });
 
-// node_modules/is-docker/index.js
-var require_is_docker = __commonJS({
-  "node_modules/is-docker/index.js"(exports, module) {
-    "use strict";
-    init_cjs_shims();
-    var fs = __require("fs");
-    var isDocker;
-    function hasDockerEnv() {
-      try {
-        fs.statSync("/.dockerenv");
-        return true;
-      } catch (_) {
-        return false;
-      }
-    }
-    function hasDockerCGroup() {
-      try {
-        return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
-      } catch (_) {
-        return false;
-      }
-    }
-    module.exports = () => {
-      if (isDocker === void 0) {
-        isDocker = hasDockerEnv() || hasDockerCGroup();
-      }
-      return isDocker;
-    };
-  }
-});
-
-// node_modules/is-wsl/index.js
-var require_is_wsl = __commonJS({
-  "node_modules/is-wsl/index.js"(exports, module) {
-    "use strict";
-    init_cjs_shims();
-    var os = __require("os");
-    var fs = __require("fs");
-    var isDocker = require_is_docker();
-    var isWsl = () => {
-      if (process.platform !== "linux") {
-        return false;
-      }
-      if (os.release().toLowerCase().includes("microsoft")) {
-        if (isDocker()) {
-          return false;
-        }
-        return true;
-      }
-      try {
-        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
-      } catch (_) {
-        return false;
-      }
-    };
-    if (process.env.__IS_WSL_TEST__) {
-      module.exports = isWsl;
-    } else {
-      module.exports = isWsl();
-    }
-  }
-});
-
 // node_modules/ms/index.js
 var require_ms = __commonJS({
   "node_modules/ms/index.js"(exports, module) {
@@ -217712,20 +217649,87 @@ var require_determine_priority = __commonJS({
   }
 });
 
+// node_modules/is-docker/index.js
+var require_is_docker = __commonJS({
+  "node_modules/is-docker/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var fs = __require("fs");
+    var isDocker;
+    function hasDockerEnv() {
+      try {
+        fs.statSync("/.dockerenv");
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }
+    function hasDockerCGroup() {
+      try {
+        return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+      } catch (_) {
+        return false;
+      }
+    }
+    module.exports = () => {
+      if (isDocker === void 0) {
+        isDocker = hasDockerEnv() || hasDockerCGroup();
+      }
+      return isDocker;
+    };
+  }
+});
+
+// node_modules/is-wsl/index.js
+var require_is_wsl = __commonJS({
+  "node_modules/is-wsl/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var os = __require("os");
+    var fs = __require("fs");
+    var isDocker = require_is_docker();
+    var isWsl = () => {
+      if (process.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isDocker()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
+      } catch (_) {
+        return false;
+      }
+    };
+    if (process.env.__IS_WSL_TEST__) {
+      module.exports = isWsl;
+    } else {
+      module.exports = isWsl();
+    }
+  }
+});
+
 // node_modules/@oclif/core/lib/util/os.js
 var require_os = __commonJS({
   "node_modules/@oclif/core/lib/util/os.js"(exports) {
     "use strict";
     init_cjs_shims();
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.getHomeDir = getHomeDir;
     exports.getPlatform = getPlatform;
+    var is_wsl_1 = __importDefault(require_is_wsl());
     var node_os_1 = __require("node:os");
     function getHomeDir() {
       return (0, node_os_1.homedir)();
     }
     function getPlatform() {
-      return (0, node_os_1.platform)();
+      return is_wsl_1.default ? "wsl" : (0, node_os_1.platform)();
     }
   }
 });
@@ -219638,631 +219642,6 @@ var require_commonjs3 = __commonJS({
   }
 });
 
-// node_modules/fdir/dist/utils.js
-var require_utils2 = __commonJS({
-  "node_modules/fdir/dist/utils.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.normalizePath = exports.isRootDirectory = exports.convertSlashes = exports.cleanPath = void 0;
-    var path_1 = __require("path");
-    function cleanPath(path) {
-      let normalized = (0, path_1.normalize)(path);
-      if (normalized.length > 1 && normalized[normalized.length - 1] === path_1.sep)
-        normalized = normalized.substring(0, normalized.length - 1);
-      return normalized;
-    }
-    exports.cleanPath = cleanPath;
-    var SLASHES_REGEX = /[\\/]/g;
-    function convertSlashes(path, separator) {
-      return path.replace(SLASHES_REGEX, separator);
-    }
-    exports.convertSlashes = convertSlashes;
-    function isRootDirectory(path) {
-      return path === "/" || /^[a-z]:\\$/i.test(path);
-    }
-    exports.isRootDirectory = isRootDirectory;
-    function normalizePath(path, options) {
-      const { resolvePaths, normalizePath: normalizePath2, pathSeparator } = options;
-      const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
-      if (resolvePaths)
-        path = (0, path_1.resolve)(path);
-      if (normalizePath2 || pathNeedsCleaning)
-        path = cleanPath(path);
-      if (path === ".")
-        return "";
-      const needsSeperator = path[path.length - 1] !== pathSeparator;
-      return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
-    }
-    exports.normalizePath = normalizePath;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/join-path.js
-var require_join_path = __commonJS({
-  "node_modules/fdir/dist/api/functions/join-path.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = exports.joinDirectoryPath = exports.joinPathWithBasePath = void 0;
-    var path_1 = __require("path");
-    var utils_1 = require_utils2();
-    function joinPathWithBasePath(filename, directoryPath) {
-      return directoryPath + filename;
-    }
-    exports.joinPathWithBasePath = joinPathWithBasePath;
-    function joinPathWithRelativePath(root, options) {
-      return function(filename, directoryPath) {
-        const sameRoot = directoryPath.startsWith(root);
-        if (sameRoot)
-          return directoryPath.replace(root, "") + filename;
-        else
-          return (0, utils_1.convertSlashes)((0, path_1.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
-      };
-    }
-    function joinPath(filename) {
-      return filename;
-    }
-    function joinDirectoryPath(filename, directoryPath, separator) {
-      return directoryPath + filename + separator;
-    }
-    exports.joinDirectoryPath = joinDirectoryPath;
-    function build(root, options) {
-      const { relativePaths, includeBasePath } = options;
-      return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/push-directory.js
-var require_push_directory = __commonJS({
-  "node_modules/fdir/dist/api/functions/push-directory.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    function pushDirectoryWithRelativePath(root) {
-      return function(directoryPath, paths) {
-        paths.push(directoryPath.substring(root.length) || ".");
-      };
-    }
-    function pushDirectoryFilterWithRelativePath(root) {
-      return function(directoryPath, paths, filters) {
-        const relativePath = directoryPath.substring(root.length) || ".";
-        if (filters.every((filter) => filter(relativePath, true))) {
-          paths.push(relativePath);
-        }
-      };
-    }
-    var pushDirectory = (directoryPath, paths) => {
-      paths.push(directoryPath || ".");
-    };
-    var pushDirectoryFilter = (directoryPath, paths, filters) => {
-      const path = directoryPath || ".";
-      if (filters.every((filter) => filter(path, true))) {
-        paths.push(path);
-      }
-    };
-    var empty = () => {
-    };
-    function build(root, options) {
-      const { includeDirs, filters, relativePaths } = options;
-      if (!includeDirs)
-        return empty;
-      if (relativePaths)
-        return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
-      return filters && filters.length ? pushDirectoryFilter : pushDirectory;
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/push-file.js
-var require_push_file = __commonJS({
-  "node_modules/fdir/dist/api/functions/push-file.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
-      if (filters.every((filter) => filter(filename, false)))
-        counts.files++;
-    };
-    var pushFileFilter = (filename, paths, _counts, filters) => {
-      if (filters.every((filter) => filter(filename, false)))
-        paths.push(filename);
-    };
-    var pushFileCount = (_filename, _paths, counts, _filters) => {
-      counts.files++;
-    };
-    var pushFile = (filename, paths) => {
-      paths.push(filename);
-    };
-    var empty = () => {
-    };
-    function build(options) {
-      const { excludeFiles, filters, onlyCounts } = options;
-      if (excludeFiles)
-        return empty;
-      if (filters && filters.length) {
-        return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
-      } else if (onlyCounts) {
-        return pushFileCount;
-      } else {
-        return pushFile;
-      }
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/get-array.js
-var require_get_array = __commonJS({
-  "node_modules/fdir/dist/api/functions/get-array.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    var getArray = (paths) => {
-      return paths;
-    };
-    var getArrayGroup = () => {
-      return [""].slice(0, 0);
-    };
-    function build(options) {
-      return options.group ? getArrayGroup : getArray;
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/group-files.js
-var require_group_files = __commonJS({
-  "node_modules/fdir/dist/api/functions/group-files.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    var groupFiles = (groups, directory, files) => {
-      groups.push({ directory, files, dir: directory });
-    };
-    var empty = () => {
-    };
-    function build(options) {
-      return options.group ? groupFiles : empty;
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/resolve-symlink.js
-var require_resolve_symlink = __commonJS({
-  "node_modules/fdir/dist/api/functions/resolve-symlink.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    var fs_1 = __importDefault(__require("fs"));
-    var path_1 = __require("path");
-    var resolveSymlinksAsync = function(path, state, callback) {
-      const { queue, options: { suppressErrors } } = state;
-      queue.enqueue();
-      fs_1.default.realpath(path, (error, resolvedPath) => {
-        if (error)
-          return queue.dequeue(suppressErrors ? null : error, state);
-        fs_1.default.stat(resolvedPath, (error2, stat) => {
-          if (error2)
-            return queue.dequeue(suppressErrors ? null : error2, state);
-          if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
-            return queue.dequeue(null, state);
-          callback(stat, resolvedPath);
-          queue.dequeue(null, state);
-        });
-      });
-    };
-    var resolveSymlinks = function(path, state, callback) {
-      const { queue, options: { suppressErrors } } = state;
-      queue.enqueue();
-      try {
-        const resolvedPath = fs_1.default.realpathSync(path);
-        const stat = fs_1.default.statSync(resolvedPath);
-        if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
-          return;
-        callback(stat, resolvedPath);
-      } catch (e) {
-        if (!suppressErrors)
-          throw e;
-      }
-    };
-    function build(options, isSynchronous) {
-      if (!options.resolveSymlinks || options.excludeSymlinks)
-        return null;
-      return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
-    }
-    exports.build = build;
-    function isRecursive(path, resolved, state) {
-      if (state.options.useRealPaths)
-        return isRecursiveUsingRealPaths(resolved, state);
-      let parent = (0, path_1.dirname)(path);
-      let depth = 1;
-      while (parent !== state.root && depth < 2) {
-        const resolvedPath = state.symlinks.get(parent);
-        const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
-        if (isSameRoot)
-          depth++;
-        else
-          parent = (0, path_1.dirname)(parent);
-      }
-      state.symlinks.set(path, resolved);
-      return depth > 1;
-    }
-    function isRecursiveUsingRealPaths(resolved, state) {
-      return state.visited.includes(resolved + state.options.pathSeparator);
-    }
-  }
-});
-
-// node_modules/fdir/dist/api/functions/invoke-callback.js
-var require_invoke_callback = __commonJS({
-  "node_modules/fdir/dist/api/functions/invoke-callback.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    var onlyCountsSync = (state) => {
-      return state.counts;
-    };
-    var groupsSync = (state) => {
-      return state.groups;
-    };
-    var defaultSync = (state) => {
-      return state.paths;
-    };
-    var limitFilesSync = (state) => {
-      return state.paths.slice(0, state.options.maxFiles);
-    };
-    var onlyCountsAsync = (state, error, callback) => {
-      report(error, callback, state.counts, state.options.suppressErrors);
-      return null;
-    };
-    var defaultAsync = (state, error, callback) => {
-      report(error, callback, state.paths, state.options.suppressErrors);
-      return null;
-    };
-    var limitFilesAsync = (state, error, callback) => {
-      report(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
-      return null;
-    };
-    var groupsAsync = (state, error, callback) => {
-      report(error, callback, state.groups, state.options.suppressErrors);
-      return null;
-    };
-    function report(error, callback, output, suppressErrors) {
-      if (error && !suppressErrors)
-        callback(error, output);
-      else
-        callback(null, output);
-    }
-    function build(options, isSynchronous) {
-      const { onlyCounts, group, maxFiles } = options;
-      if (onlyCounts)
-        return isSynchronous ? onlyCountsSync : onlyCountsAsync;
-      else if (group)
-        return isSynchronous ? groupsSync : groupsAsync;
-      else if (maxFiles)
-        return isSynchronous ? limitFilesSync : limitFilesAsync;
-      else
-        return isSynchronous ? defaultSync : defaultAsync;
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/functions/walk-directory.js
-var require_walk_directory = __commonJS({
-  "node_modules/fdir/dist/api/functions/walk-directory.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.build = void 0;
-    var fs_1 = __importDefault(__require("fs"));
-    var readdirOpts = { withFileTypes: true };
-    var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback) => {
-      if (currentDepth < 0)
-        return state.queue.dequeue(null, state);
-      state.visited.push(crawlPath);
-      state.counts.directories++;
-      state.queue.enqueue();
-      fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
-        callback(entries, directoryPath, currentDepth);
-        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
-      });
-    };
-    var walkSync = (state, crawlPath, directoryPath, currentDepth, callback) => {
-      if (currentDepth < 0)
-        return;
-      state.visited.push(crawlPath);
-      state.counts.directories++;
-      let entries = [];
-      try {
-        entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
-      } catch (e) {
-        if (!state.options.suppressErrors)
-          throw e;
-      }
-      callback(entries, directoryPath, currentDepth);
-    };
-    function build(isSynchronous) {
-      return isSynchronous ? walkSync : walkAsync;
-    }
-    exports.build = build;
-  }
-});
-
-// node_modules/fdir/dist/api/queue.js
-var require_queue = __commonJS({
-  "node_modules/fdir/dist/api/queue.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Queue = void 0;
-    var Queue = class {
-      onQueueEmpty;
-      count = 0;
-      constructor(onQueueEmpty) {
-        this.onQueueEmpty = onQueueEmpty;
-      }
-      enqueue() {
-        this.count++;
-      }
-      dequeue(error, output) {
-        if (--this.count <= 0 || error)
-          this.onQueueEmpty(error, output);
-      }
-    };
-    exports.Queue = Queue;
-  }
-});
-
-// node_modules/fdir/dist/api/counter.js
-var require_counter = __commonJS({
-  "node_modules/fdir/dist/api/counter.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Counter = void 0;
-    var Counter = class {
-      _files = 0;
-      _directories = 0;
-      set files(num) {
-        this._files = num;
-      }
-      get files() {
-        return this._files;
-      }
-      set directories(num) {
-        this._directories = num;
-      }
-      get directories() {
-        return this._directories;
-      }
-      /**
-       * @deprecated use `directories` instead
-       */
-      /* c8 ignore next 3 */
-      get dirs() {
-        return this._directories;
-      }
-    };
-    exports.Counter = Counter;
-  }
-});
-
-// node_modules/fdir/dist/api/walker.js
-var require_walker = __commonJS({
-  "node_modules/fdir/dist/api/walker.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports && exports.__importStar || function(mod) {
-      if (mod && mod.__esModule) return mod;
-      var result = {};
-      if (mod != null) {
-        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-      }
-      __setModuleDefault(result, mod);
-      return result;
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Walker = void 0;
-    var path_1 = __require("path");
-    var utils_1 = require_utils2();
-    var joinPath = __importStar(require_join_path());
-    var pushDirectory = __importStar(require_push_directory());
-    var pushFile = __importStar(require_push_file());
-    var getArray = __importStar(require_get_array());
-    var groupFiles = __importStar(require_group_files());
-    var resolveSymlink = __importStar(require_resolve_symlink());
-    var invokeCallback = __importStar(require_invoke_callback());
-    var walkDirectory = __importStar(require_walk_directory());
-    var queue_1 = require_queue();
-    var counter_1 = require_counter();
-    var Walker = class {
-      root;
-      isSynchronous;
-      state;
-      joinPath;
-      pushDirectory;
-      pushFile;
-      getArray;
-      groupFiles;
-      resolveSymlink;
-      walkDirectory;
-      callbackInvoker;
-      constructor(root, options, callback) {
-        this.isSynchronous = !callback;
-        this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
-        this.root = (0, utils_1.normalizePath)(root, options);
-        this.state = {
-          root: (0, utils_1.isRootDirectory)(this.root) ? this.root : this.root.slice(0, -1),
-          // Perf: we explicitly tell the compiler to optimize for String arrays
-          paths: [""].slice(0, 0),
-          groups: [],
-          counts: new counter_1.Counter(),
-          options,
-          queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback)),
-          symlinks: /* @__PURE__ */ new Map(),
-          visited: [""].slice(0, 0)
-        };
-        this.joinPath = joinPath.build(this.root, options);
-        this.pushDirectory = pushDirectory.build(this.root, options);
-        this.pushFile = pushFile.build(options);
-        this.getArray = getArray.build(options);
-        this.groupFiles = groupFiles.build(options);
-        this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
-        this.walkDirectory = walkDirectory.build(this.isSynchronous);
-      }
-      start() {
-        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
-        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
-      }
-      walk = (entries, directoryPath, depth) => {
-        const { paths, options: { filters, resolveSymlinks, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator } } = this.state;
-        if (signal && signal.aborted || maxFiles && paths.length > maxFiles)
-          return;
-        this.pushDirectory(directoryPath, paths, filters);
-        const files = this.getArray(this.state.paths);
-        for (let i = 0; i < entries.length; ++i) {
-          const entry = entries[i];
-          if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks && !excludeSymlinks) {
-            const filename = this.joinPath(entry.name, directoryPath);
-            this.pushFile(filename, files, this.state.counts, filters);
-          } else if (entry.isDirectory()) {
-            let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-            if (exclude && exclude(entry.name, path))
-              continue;
-            this.walkDirectory(this.state, path, path, depth - 1, this.walk);
-          } else if (entry.isSymbolicLink() && this.resolveSymlink) {
-            let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
-              if (stat.isDirectory()) {
-                resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
-                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator))
-                  return;
-                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
-              } else {
-                resolvedPath = useRealPaths ? resolvedPath : path;
-                const filename = (0, path_1.basename)(resolvedPath);
-                const directoryPath2 = (0, utils_1.normalizePath)((0, path_1.dirname)(resolvedPath), this.state.options);
-                resolvedPath = this.joinPath(filename, directoryPath2);
-                this.pushFile(resolvedPath, files, this.state.counts, filters);
-              }
-            });
-          }
-        }
-        this.groupFiles(this.state.groups, directoryPath, files);
-      };
-    };
-    exports.Walker = Walker;
-  }
-});
-
-// node_modules/fdir/dist/api/async.js
-var require_async2 = __commonJS({
-  "node_modules/fdir/dist/api/async.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.callback = exports.promise = void 0;
-    var walker_1 = require_walker();
-    function promise(root, options) {
-      return new Promise((resolve, reject) => {
-        callback(root, options, (err, output) => {
-          if (err)
-            return reject(err);
-          resolve(output);
-        });
-      });
-    }
-    exports.promise = promise;
-    function callback(root, options, callback2) {
-      let walker = new walker_1.Walker(root, options, callback2);
-      walker.start();
-    }
-    exports.callback = callback;
-  }
-});
-
-// node_modules/fdir/dist/api/sync.js
-var require_sync2 = __commonJS({
-  "node_modules/fdir/dist/api/sync.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.sync = void 0;
-    var walker_1 = require_walker();
-    function sync(root, options) {
-      const walker = new walker_1.Walker(root, options);
-      return walker.start();
-    }
-    exports.sync = sync;
-  }
-});
-
-// node_modules/fdir/dist/builder/api-builder.js
-var require_api_builder = __commonJS({
-  "node_modules/fdir/dist/builder/api-builder.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.APIBuilder = void 0;
-    var async_1 = require_async2();
-    var sync_1 = require_sync2();
-    var APIBuilder = class {
-      root;
-      options;
-      constructor(root, options) {
-        this.root = root;
-        this.options = options;
-      }
-      withPromise() {
-        return (0, async_1.promise)(this.root, this.options);
-      }
-      withCallback(cb) {
-        (0, async_1.callback)(this.root, this.options, cb);
-      }
-      sync() {
-        return (0, sync_1.sync)(this.root, this.options);
-      }
-    };
-    exports.APIBuilder = APIBuilder;
-  }
-});
-
 // node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS({
   "node_modules/picomatch/lib/constants.js"(exports, module) {
@@ -220347,6 +219726,7 @@ var require_constants = __commonJS({
       REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
       // Replace globs with equivalent patterns to reduce parsing time.
       REPLACEMENTS: {
+        __proto__: null,
         "***": "*",
         "**/**": "**",
         "**/**/**": "**"
@@ -220463,7 +219843,7 @@ var require_constants = __commonJS({
 });
 
 // node_modules/picomatch/lib/utils.js
-var require_utils3 = __commonJS({
+var require_utils2 = __commonJS({
   "node_modules/picomatch/lib/utils.js"(exports) {
     "use strict";
     init_cjs_shims();
@@ -220532,7 +219912,7 @@ var require_scan = __commonJS({
   "node_modules/picomatch/lib/scan.js"(exports, module) {
     "use strict";
     init_cjs_shims();
-    var utils = require_utils3();
+    var utils = require_utils2();
     var {
       CHAR_ASTERISK,
       /* * */
@@ -220864,7 +220244,7 @@ var require_parse = __commonJS({
     "use strict";
     init_cjs_shims();
     var constants = require_constants();
-    var utils = require_utils3();
+    var utils = require_utils2();
     var {
       MAX_LENGTH,
       POSIX_REGEX_SOURCE,
@@ -221634,7 +221014,7 @@ var require_picomatch = __commonJS({
     init_cjs_shims();
     var scan = require_scan();
     var parse = require_parse();
-    var utils = require_utils3();
+    var utils = require_utils2();
     var constants = require_constants();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
     var picomatch = (glob, options, returnState = false) => {
@@ -221774,7 +221154,7 @@ var require_picomatch2 = __commonJS({
     "use strict";
     init_cjs_shims();
     var pico = require_picomatch();
-    var utils = require_utils3();
+    var utils = require_utils2();
     function picomatch(glob, options, returnState = false) {
       if (options && (options.windows === null || options.windows === void 0)) {
         options = { ...options, windows: utils.isWindows() };
@@ -221786,32 +221166,428 @@ var require_picomatch2 = __commonJS({
   }
 });
 
-// node_modules/fdir/dist/builder/index.js
-var require_builder = __commonJS({
-  "node_modules/fdir/dist/builder/index.js"(exports) {
-    "use strict";
+// node_modules/fdir/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/fdir/dist/index.cjs"(exports) {
     init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Builder = void 0;
-    var path_1 = __require("path");
-    var api_builder_1 = require_api_builder();
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+        key = keys[i];
+        if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+      }
+      return to;
+    };
+    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+      value: mod,
+      enumerable: true
+    }) : target, mod));
+    var path = __toESM(__require("path"));
+    var fs = __toESM(__require("fs"));
+    function cleanPath(path$1) {
+      let normalized = (0, path.normalize)(path$1);
+      if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1);
+      return normalized;
+    }
+    var SLASHES_REGEX = /[\\/]/g;
+    function convertSlashes(path$1, separator) {
+      return path$1.replace(SLASHES_REGEX, separator);
+    }
+    var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+    function isRootDirectory(path$1) {
+      return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
+    }
+    function normalizePath(path$1, options) {
+      const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+      const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
+      if (resolvePaths) path$1 = (0, path.resolve)(path$1);
+      if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
+      if (path$1 === ".") return "";
+      const needsSeperator = path$1[path$1.length - 1] !== pathSeparator;
+      return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator);
+    }
+    function joinPathWithBasePath(filename, directoryPath) {
+      return directoryPath + filename;
+    }
+    function joinPathWithRelativePath(root, options) {
+      return function(filename, directoryPath) {
+        const sameRoot = directoryPath.startsWith(root);
+        if (sameRoot) return directoryPath.slice(root.length) + filename;
+        else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+      };
+    }
+    function joinPath(filename) {
+      return filename;
+    }
+    function joinDirectoryPath(filename, directoryPath, separator) {
+      return directoryPath + filename + separator;
+    }
+    function build$7(root, options) {
+      const { relativePaths, includeBasePath } = options;
+      return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+    }
+    function pushDirectoryWithRelativePath(root) {
+      return function(directoryPath, paths) {
+        paths.push(directoryPath.substring(root.length) || ".");
+      };
+    }
+    function pushDirectoryFilterWithRelativePath(root) {
+      return function(directoryPath, paths, filters) {
+        const relativePath = directoryPath.substring(root.length) || ".";
+        if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
+      };
+    }
+    var pushDirectory = (directoryPath, paths) => {
+      paths.push(directoryPath || ".");
+    };
+    var pushDirectoryFilter = (directoryPath, paths, filters) => {
+      const path$1 = directoryPath || ".";
+      if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
+    };
+    var empty$2 = () => {
+    };
+    function build$6(root, options) {
+      const { includeDirs, filters, relativePaths } = options;
+      if (!includeDirs) return empty$2;
+      if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+      return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+    }
+    var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+      if (filters.every((filter) => filter(filename, false))) counts.files++;
+    };
+    var pushFileFilter = (filename, paths, _counts, filters) => {
+      if (filters.every((filter) => filter(filename, false))) paths.push(filename);
+    };
+    var pushFileCount = (_filename, _paths, counts, _filters) => {
+      counts.files++;
+    };
+    var pushFile = (filename, paths) => {
+      paths.push(filename);
+    };
+    var empty$1 = () => {
+    };
+    function build$5(options) {
+      const { excludeFiles, filters, onlyCounts } = options;
+      if (excludeFiles) return empty$1;
+      if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+      else if (onlyCounts) return pushFileCount;
+      else return pushFile;
+    }
+    var getArray = (paths) => {
+      return paths;
+    };
+    var getArrayGroup = () => {
+      return [""].slice(0, 0);
+    };
+    function build$4(options) {
+      return options.group ? getArrayGroup : getArray;
+    }
+    var groupFiles = (groups, directory, files) => {
+      groups.push({
+        directory,
+        files,
+        dir: directory
+      });
+    };
+    var empty = () => {
+    };
+    function build$3(options) {
+      return options.group ? groupFiles : empty;
+    }
+    var resolveSymlinksAsync = function(path$1, state, callback$1) {
+      const { queue, fs: fs$1, options: { suppressErrors } } = state;
+      queue.enqueue();
+      fs$1.realpath(path$1, (error, resolvedPath) => {
+        if (error) return queue.dequeue(suppressErrors ? null : error, state);
+        fs$1.stat(resolvedPath, (error$1, stat) => {
+          if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+          if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
+          callback$1(stat, resolvedPath);
+          queue.dequeue(null, state);
+        });
+      });
+    };
+    var resolveSymlinks = function(path$1, state, callback$1) {
+      const { queue, fs: fs$1, options: { suppressErrors } } = state;
+      queue.enqueue();
+      try {
+        const resolvedPath = fs$1.realpathSync(path$1);
+        const stat = fs$1.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
+        callback$1(stat, resolvedPath);
+      } catch (e) {
+        if (!suppressErrors) throw e;
+      }
+    };
+    function build$2(options, isSynchronous) {
+      if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+      return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+    }
+    function isRecursive(path$1, resolved, state) {
+      if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+      let parent = (0, path.dirname)(path$1);
+      let depth = 1;
+      while (parent !== state.root && depth < 2) {
+        const resolvedPath = state.symlinks.get(parent);
+        const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+        if (isSameRoot) depth++;
+        else parent = (0, path.dirname)(parent);
+      }
+      state.symlinks.set(path$1, resolved);
+      return depth > 1;
+    }
+    function isRecursiveUsingRealPaths(resolved, state) {
+      return state.visited.includes(resolved + state.options.pathSeparator);
+    }
+    var onlyCountsSync = (state) => {
+      return state.counts;
+    };
+    var groupsSync = (state) => {
+      return state.groups;
+    };
+    var defaultSync = (state) => {
+      return state.paths;
+    };
+    var limitFilesSync = (state) => {
+      return state.paths.slice(0, state.options.maxFiles);
+    };
+    var onlyCountsAsync = (state, error, callback$1) => {
+      report(error, callback$1, state.counts, state.options.suppressErrors);
+      return null;
+    };
+    var defaultAsync = (state, error, callback$1) => {
+      report(error, callback$1, state.paths, state.options.suppressErrors);
+      return null;
+    };
+    var limitFilesAsync = (state, error, callback$1) => {
+      report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+      return null;
+    };
+    var groupsAsync = (state, error, callback$1) => {
+      report(error, callback$1, state.groups, state.options.suppressErrors);
+      return null;
+    };
+    function report(error, callback$1, output, suppressErrors) {
+      if (error && !suppressErrors) callback$1(error, output);
+      else callback$1(null, output);
+    }
+    function build$1(options, isSynchronous) {
+      const { onlyCounts, group, maxFiles } = options;
+      if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+      else if (group) return isSynchronous ? groupsSync : groupsAsync;
+      else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+      else return isSynchronous ? defaultSync : defaultAsync;
+    }
+    var readdirOpts = { withFileTypes: true };
+    var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+      state.queue.enqueue();
+      if (currentDepth < 0) return state.queue.dequeue(null, state);
+      const { fs: fs$1 } = state;
+      state.visited.push(crawlPath);
+      state.counts.directories++;
+      fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+        callback$1(entries, directoryPath, currentDepth);
+        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+      });
+    };
+    var walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+      const { fs: fs$1 } = state;
+      if (currentDepth < 0) return;
+      state.visited.push(crawlPath);
+      state.counts.directories++;
+      let entries = [];
+      try {
+        entries = fs$1.readdirSync(crawlPath || ".", readdirOpts);
+      } catch (e) {
+        if (!state.options.suppressErrors) throw e;
+      }
+      callback$1(entries, directoryPath, currentDepth);
+    };
+    function build(isSynchronous) {
+      return isSynchronous ? walkSync : walkAsync;
+    }
+    var Queue = class {
+      count = 0;
+      constructor(onQueueEmpty) {
+        this.onQueueEmpty = onQueueEmpty;
+      }
+      enqueue() {
+        this.count++;
+        return this.count;
+      }
+      dequeue(error, output) {
+        if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+          this.onQueueEmpty(error, output);
+          if (error) {
+            output.controller.abort();
+            this.onQueueEmpty = void 0;
+          }
+        }
+      }
+    };
+    var Counter = class {
+      _files = 0;
+      _directories = 0;
+      set files(num) {
+        this._files = num;
+      }
+      get files() {
+        return this._files;
+      }
+      set directories(num) {
+        this._directories = num;
+      }
+      get directories() {
+        return this._directories;
+      }
+      /**
+      * @deprecated use `directories` instead
+      */
+      /* c8 ignore next 3 */
+      get dirs() {
+        return this._directories;
+      }
+    };
+    var Aborter = class {
+      aborted = false;
+      abort() {
+        this.aborted = true;
+      }
+    };
+    var Walker = class {
+      root;
+      isSynchronous;
+      state;
+      joinPath;
+      pushDirectory;
+      pushFile;
+      getArray;
+      groupFiles;
+      resolveSymlink;
+      walkDirectory;
+      callbackInvoker;
+      constructor(root, options, callback$1) {
+        this.isSynchronous = !callback$1;
+        this.callbackInvoker = build$1(options, this.isSynchronous);
+        this.root = normalizePath(root, options);
+        this.state = {
+          root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+          paths: [""].slice(0, 0),
+          groups: [],
+          counts: new Counter(),
+          options,
+          queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+          symlinks: /* @__PURE__ */ new Map(),
+          visited: [""].slice(0, 0),
+          controller: new Aborter(),
+          fs: options.fs || fs
+        };
+        this.joinPath = build$7(this.root, options);
+        this.pushDirectory = build$6(this.root, options);
+        this.pushFile = build$5(options);
+        this.getArray = build$4(options);
+        this.groupFiles = build$3(options);
+        this.resolveSymlink = build$2(options, this.isSynchronous);
+        this.walkDirectory = build(this.isSynchronous);
+      }
+      start() {
+        this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+      }
+      walk = (entries, directoryPath, depth) => {
+        const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+        if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+        const files = this.getArray(this.state.paths);
+        for (let i = 0; i < entries.length; ++i) {
+          const entry = entries[i];
+          if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+            const filename = this.joinPath(entry.name, directoryPath);
+            this.pushFile(filename, files, this.state.counts, filters);
+          } else if (entry.isDirectory()) {
+            let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+            if (exclude && exclude(entry.name, path$1)) continue;
+            this.pushDirectory(path$1, paths, filters);
+            this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);
+          } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+            let path$1 = joinPathWithBasePath(entry.name, directoryPath);
+            this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => {
+              if (stat.isDirectory()) {
+                resolvedPath = normalizePath(resolvedPath, this.state.options);
+                if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
+                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);
+              } else {
+                resolvedPath = useRealPaths ? resolvedPath : path$1;
+                const filename = (0, path.basename)(resolvedPath);
+                const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options);
+                resolvedPath = this.joinPath(filename, directoryPath$1);
+                this.pushFile(resolvedPath, files, this.state.counts, filters);
+              }
+            });
+          }
+        }
+        this.groupFiles(this.state.groups, directoryPath, files);
+      };
+    };
+    function promise(root, options) {
+      return new Promise((resolve$1, reject) => {
+        callback(root, options, (err, output) => {
+          if (err) return reject(err);
+          resolve$1(output);
+        });
+      });
+    }
+    function callback(root, options, callback$1) {
+      let walker = new Walker(root, options, callback$1);
+      walker.start();
+    }
+    function sync(root, options) {
+      const walker = new Walker(root, options);
+      return walker.start();
+    }
+    var APIBuilder = class {
+      constructor(root, options) {
+        this.root = root;
+        this.options = options;
+      }
+      withPromise() {
+        return promise(this.root, this.options);
+      }
+      withCallback(cb) {
+        callback(this.root, this.options, cb);
+      }
+      sync() {
+        return sync(this.root, this.options);
+      }
+    };
     var pm = null;
     try {
       __require.resolve("picomatch");
       pm = require_picomatch2();
-    } catch (_e) {
+    } catch {
     }
     var Builder = class {
       globCache = {};
       options = {
         maxDepth: Infinity,
         suppressErrors: true,
-        pathSeparator: path_1.sep,
+        pathSeparator: path.sep,
         filters: []
       };
       globFunction;
       constructor(options) {
-        this.options = { ...this.options, ...options };
+        this.options = {
+          ...this.options,
+          ...options
+        };
         this.globFunction = this.options.globFunction;
       }
       group() {
@@ -221882,91 +221658,50 @@ var require_builder = __commonJS({
         return this;
       }
       crawl(root) {
-        return new api_builder_1.APIBuilder(root || ".", this.options);
+        return new APIBuilder(root || ".", this.options);
       }
       withGlobFunction(fn) {
         this.globFunction = fn;
         return this;
       }
       /**
-       * @deprecated Pass options using the constructor instead:
-       * ```ts
-       * new fdir(options).crawl("/path/to/root");
-       * ```
-       * This method will be removed in v7.0
-       */
+      * @deprecated Pass options using the constructor instead:
+      * ```ts
+      * new fdir(options).crawl("/path/to/root");
+      * ```
+      * This method will be removed in v7.0
+      */
       /* c8 ignore next 4 */
       crawlWithOptions(root, options) {
-        this.options = { ...this.options, ...options };
-        return new api_builder_1.APIBuilder(root || ".", this.options);
+        this.options = {
+          ...this.options,
+          ...options
+        };
+        return new APIBuilder(root || ".", this.options);
       }
       glob(...patterns) {
-        if (this.globFunction) {
-          return this.globWithOptions(patterns);
-        }
+        if (this.globFunction) return this.globWithOptions(patterns);
         return this.globWithOptions(patterns, ...[{ dot: true }]);
       }
       globWithOptions(patterns, ...options) {
         const globFn = this.globFunction || pm;
-        if (!globFn) {
-          throw new Error("Please specify a glob function to use glob matching.");
-        }
+        if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
         var isMatch = this.globCache[patterns.join("\0")];
         if (!isMatch) {
           isMatch = globFn(patterns, ...options);
           this.globCache[patterns.join("\0")] = isMatch;
         }
-        this.options.filters.push((path) => isMatch(path));
+        this.options.filters.push((path$1) => isMatch(path$1));
         return this;
       }
     };
-    exports.Builder = Builder;
-  }
-});
-
-// node_modules/fdir/dist/types.js
-var require_types = __commonJS({
-  "node_modules/fdir/dist/types.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fdir = Builder;
   }
 });
 
-// node_modules/fdir/dist/index.js
-var require_dist = __commonJS({
-  "node_modules/fdir/dist/index.js"(exports) {
-    "use strict";
-    init_cjs_shims();
-    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.fdir = void 0;
-    var builder_1 = require_builder();
-    Object.defineProperty(exports, "fdir", { enumerable: true, get: function() {
-      return builder_1.Builder;
-    } });
-    __exportStar(require_types(), exports);
-  }
-});
-
-// node_modules/tinyglobby/dist/index.js
+// node_modules/tinyglobby/dist/index.cjs
 var require_dist2 = __commonJS({
-  "node_modules/tinyglobby/dist/index.js"(exports) {
+  "node_modules/tinyglobby/dist/index.cjs"(exports) {
     init_cjs_shims();
     var __create = Object.create;
     var __defProp = Object.defineProperty;
@@ -221988,37 +221723,47 @@ var require_dist2 = __commonJS({
       value: mod,
       enumerable: true
     }) : target, mod));
-    var path = __toESM(__require("path"));
-    var fdir = __toESM(require_dist());
-    var picomatch = __toESM(require_picomatch2());
+    var fs = __require("fs");
+    fs = __toESM(fs);
+    var path = __require("path");
+    path = __toESM(path);
+    var url = __require("url");
+    url = __toESM(url);
+    var fdir = require_dist();
+    fdir = __toESM(fdir);
+    var picomatch = require_picomatch2();
+    picomatch = __toESM(picomatch);
+    var isReadonlyArray = Array.isArray;
+    var isWin = process.platform === "win32";
     var ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
-    function getPartialMatcher(patterns, options) {
+    function getPartialMatcher(patterns, options = {}) {
       const patternsCount = patterns.length;
       const patternsParts = Array(patternsCount);
-      const regexes = Array(patternsCount);
+      const matchers = Array(patternsCount);
+      const globstarEnabled = !options.noglobstar;
       for (let i = 0; i < patternsCount; i++) {
         const parts = splitPattern(patterns[i]);
         patternsParts[i] = parts;
         const partsCount = parts.length;
-        const partRegexes = Array(partsCount);
-        for (let j = 0; j < partsCount; j++) partRegexes[j] = picomatch.default.makeRe(parts[j], options);
-        regexes[i] = partRegexes;
+        const partMatchers = Array(partsCount);
+        for (let j = 0; j < partsCount; j++) partMatchers[j] = (0, picomatch.default)(parts[j], options);
+        matchers[i] = partMatchers;
       }
       return (input) => {
         const inputParts = input.split("/");
         if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
         for (let i = 0; i < patterns.length; i++) {
           const patternParts = patternsParts[i];
-          const regex = regexes[i];
+          const matcher = matchers[i];
           const inputPatternCount = inputParts.length;
           const minParts = Math.min(inputPatternCount, patternParts.length);
           let j = 0;
           while (j < minParts) {
             const part = patternParts[j];
             if (part.includes("/")) return true;
-            const match = regex[j].test(inputParts[j]);
+            const match = matcher[j](inputParts[j]);
             if (!match) break;
-            if (part === "**") return true;
+            if (globstarEnabled && part === "**") return true;
             j++;
           }
           if (j === inputPatternCount) return true;
@@ -222026,13 +221771,42 @@ var require_dist2 = __commonJS({
         return false;
       };
     }
+    var WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+    var isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
+    function buildFormat(cwd, root, absolute) {
+      if (cwd === root || root.startsWith(`${cwd}/`)) {
+        if (absolute) {
+          const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+          return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
+        }
+        const prefix = root.slice(cwd.length + 1);
+        if (prefix) return (p, isDir) => {
+          if (p === ".") return prefix;
+          const result = `${prefix}/${p}`;
+          return isDir ? result.slice(0, -1) : result;
+        };
+        return (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
+      }
+      if (absolute) return (p) => path.posix.relative(cwd, p) || ".";
+      return (p) => path.posix.relative(cwd, `${root}/${p}`) || ".";
+    }
+    function buildRelative(cwd, root) {
+      if (root.startsWith(`${cwd}/`)) {
+        const prefix = root.slice(cwd.length + 1);
+        return (p) => `${prefix}/${p}`;
+      }
+      return (p) => {
+        const result = path.posix.relative(cwd, `${root}/${p}`);
+        if (p.endsWith("/") && result !== "") return `${result}/`;
+        return result || ".";
+      };
+    }
     var splitPatternOptions = { parts: true };
     function splitPattern(path$2) {
       var _result$parts;
       const result = picomatch.default.scan(path$2, splitPatternOptions);
       return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$2];
     }
-    var isWin = process.platform === "win32";
     var ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
     function convertPosixPathToPattern(path$2) {
       return escapePosixPath(path$2);
@@ -222096,13 +221870,12 @@ var require_dist2 = __commonJS({
         }
         props.depthOffset = newCommonPath.length;
         props.commonPath = newCommonPath;
-        props.root = newCommonPath.length > 0 ? path.default.posix.join(cwd, ...newCommonPath) : cwd;
+        props.root = newCommonPath.length > 0 ? path.posix.join(cwd, ...newCommonPath) : cwd;
       }
       return result;
     }
-    function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
+    function processPatterns({ patterns = ["**/*"], ignore = [], expandDirectories = true }, cwd, props) {
       if (typeof patterns === "string") patterns = [patterns];
-      else if (!patterns) patterns = ["**/*"];
       if (typeof ignore === "string") ignore = [ignore];
       const matchPatterns = [];
       const ignorePatterns = [];
@@ -222120,66 +221893,88 @@ var require_dist2 = __commonJS({
         ignore: ignorePatterns
       };
     }
-    function getRelativePath(path$2, cwd, root) {
-      return path.posix.relative(cwd, `${root}/${path$2}`) || ".";
-    }
-    function processPath(path$2, cwd, root, isDirectory, absolute) {
-      const relativePath = absolute ? path$2.slice(root === "/" ? 1 : root.length + 1) || "." : path$2;
-      if (root === cwd) return isDirectory && relativePath !== "." ? relativePath.slice(0, -1) : relativePath;
-      return getRelativePath(relativePath, cwd, root);
-    }
-    function formatPaths(paths, cwd, root) {
+    function formatPaths(paths, relative) {
       for (let i = paths.length - 1; i >= 0; i--) {
         const path$2 = paths[i];
-        paths[i] = getRelativePath(path$2, cwd, root) + (!path$2 || path$2.endsWith("/") ? "/" : "");
+        paths[i] = relative(path$2);
       }
       return paths;
     }
-    function crawl(options, cwd, sync) {
-      if (process.env.TINYGLOBBY_DEBUG) options.debug = true;
-      if (options.debug) log("globbing with options:", options, "cwd:", cwd);
-      if (Array.isArray(options.patterns) && options.patterns.length === 0) return sync ? [] : Promise.resolve([]);
+    function normalizeCwd(cwd) {
+      if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
+      if (cwd instanceof URL) return (0, url.fileURLToPath)(cwd).replace(BACKSLASHES, "/");
+      return path.default.resolve(cwd).replace(BACKSLASHES, "/");
+    }
+    function getCrawler(patterns, inputOptions = {}) {
+      const options = process.env.TINYGLOBBY_DEBUG ? {
+        ...inputOptions,
+        debug: true
+      } : inputOptions;
+      const cwd = normalizeCwd(options.cwd);
+      if (options.debug) log("globbing with:", {
+        patterns,
+        options,
+        cwd
+      });
+      if (Array.isArray(patterns) && patterns.length === 0) return [{
+        sync: () => [],
+        withPromise: async () => []
+      }, false];
       const props = {
         root: cwd,
         commonPath: null,
         depthOffset: 0
       };
-      const processed = processPatterns(options, cwd, props);
-      const nocase = options.caseSensitiveMatch === false;
+      const processed = processPatterns({
+        ...options,
+        patterns
+      }, cwd, props);
       if (options.debug) log("internal processing patterns:", processed);
-      const matcher = (0, picomatch.default)(processed.match, {
+      const matchOptions = {
         dot: options.dot,
-        nocase,
+        nobrace: options.braceExpansion === false,
+        nocase: options.caseSensitiveMatch === false,
+        noextglob: options.extglob === false,
+        noglobstar: options.globstar === false,
+        posix: true
+      };
+      const matcher = (0, picomatch.default)(processed.match, {
+        ...matchOptions,
         ignore: processed.ignore
       });
-      const ignore = (0, picomatch.default)(processed.ignore, {
-        dot: options.dot,
-        nocase
-      });
-      const partialMatcher = getPartialMatcher(processed.match, {
-        dot: options.dot,
-        nocase
-      });
+      const ignore = (0, picomatch.default)(processed.ignore, matchOptions);
+      const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+      const format = buildFormat(cwd, props.root, options.absolute);
+      const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
       const fdirOptions = {
         filters: [options.debug ? (p, isDirectory) => {
-          const path$2 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+          const path$2 = format(p, isDirectory);
           const matches = matcher(path$2);
           if (matches) log(`matched ${path$2}`);
           return matches;
-        } : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))],
+        } : (p, isDirectory) => matcher(format(p, isDirectory))],
         exclude: options.debug ? (_, p) => {
-          const relativePath = processPath(p, cwd, props.root, true, true);
+          const relativePath = formatExclude(p, true);
           const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
           if (skipped) log(`skipped ${p}`);
           else log(`crawling ${p}`);
           return skipped;
         } : (_, p) => {
-          const relativePath = processPath(p, cwd, props.root, true, true);
+          const relativePath = formatExclude(p, true);
           return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
         },
+        fs: options.fs ? {
+          readdir: options.fs.readdir || fs.default.readdir,
+          readdirSync: options.fs.readdirSync || fs.default.readdirSync,
+          realpath: options.fs.realpath || fs.default.realpath,
+          realpathSync: options.fs.realpathSync || fs.default.realpathSync,
+          stat: options.fs.stat || fs.default.stat,
+          statSync: options.fs.statSync || fs.default.statSync
+        } : void 0,
         pathSeparator: "/",
         relativePaths: true,
-        resolveSymlinks: true
+        resolveSymlinks: true,
+        signal: options.signal
       };
       if (options.deep !== void 0) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
       if (options.absolute) {
@@ -222198,27 +221993,26 @@ var require_dist2 = __commonJS({
       props.root = props.root.replace(BACKSLASHES, "");
       const root = props.root;
       if (options.debug) log("internal properties:", props);
-      const api = new fdir.fdir(fdirOptions).crawl(root);
-      if (cwd === root || options.absolute) return sync ? api.sync() : api.withPromise();
-      return sync ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths) => formatPaths(paths, cwd, root));
+      const relative = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+      return [new fdir.fdir(fdirOptions).crawl(root), relative];
     }
     async function glob(patternsOrOptions, options) {
       if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
-      const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
-        ...options,
-        patterns: patternsOrOptions
-      } : patternsOrOptions;
-      const cwd = opts.cwd ? path.default.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
-      return crawl(opts, cwd, false);
+      const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
+      const opts = isModern ? options : patternsOrOptions;
+      const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
+      const [crawler, relative] = getCrawler(patterns, opts);
+      if (!relative) return crawler.withPromise();
+      return formatPaths(await crawler.withPromise(), relative);
     }
     function globSync(patternsOrOptions, options) {
       if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
-      const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
-        ...options,
-        patterns: patternsOrOptions
-      } : patternsOrOptions;
-      const cwd = opts.cwd ? path.default.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
-      return crawl(opts, cwd, true);
+      const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
+      const opts = isModern ? options : patternsOrOptions;
+      const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
+      const [crawler, relative] = getCrawler(patterns, opts);
+      if (!relative) return crawler.sync();
+      return formatPaths(crawler.sync(), relative);
     }
     exports.convertPathToPattern = convertPathToPattern;
     exports.escapePath = escapePath;
@@ -223620,7 +223414,6 @@ var require_config = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Config = void 0;
     var ejs = __importStar(require_ejs());
-    var is_wsl_1 = __importDefault(require_is_wsl());
     var node_os_1 = __require("node:os");
     var node_path_1 = __require("node:path");
     var node_url_1 = __require("node:url");
@@ -223881,7 +223674,7 @@ var require_config = __commonJS({
         this.channel = this.options.channel || channelFromVersion(this.version);
         this.valid = this.rootPlugin.valid;
         this.arch = (0, node_os_1.arch)() === "ia32" ? "x86" : (0, node_os_1.arch)();
-        this.platform = is_wsl_1.default ? "wsl" : (0, os_1.getPlatform)();
+        this.platform = (0, os_1.getPlatform)();
         this.windows = this.platform === "win32";
         this.bin = this.pjson.oclif.bin || this.name;
         this.binAliases = this.pjson.oclif.binAliases;