@aussieljk/forkbook 0.0.1-4 → 0.0.1-6

package/dist/_node-chunks/chunk-YCXTTQ7K.js

@@ -0,0 +1,620 @@
+import CJS_COMPAT_NODE_URL_7qov04rgzsv from 'node:url';
+import CJS_COMPAT_NODE_PATH_7qov04rgzsv from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7qov04rgzsv from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_7qov04rgzsv.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7qov04rgzsv.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7qov04rgzsv.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  require_picomatch
+} from "./chunk-ZCITDAV4.js";
+import {
+  __toESM
+} from "./chunk-A35J7YYA.js";
+
+// ../../node_modules/tinyglobby/dist/index.mjs
+import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
+import { isAbsolute, posix, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// ../../node_modules/fdir/dist/index.mjs
+import { createRequire } from "module";
+import { basename, dirname, normalize, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+var __require = createRequire(import.meta.url);
+function cleanPath(path) {
+  let normalized = normalize(path);
+  return normalized.length > 1 && normalized[normalized.length - 1] === sep && (normalized = normalized.substring(0, normalized.length - 1)), normalized;
+}
+var SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+  return path.replace(SLASHES_REGEX, separator);
+}
+var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+  return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+  let { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options, pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
+  if (resolvePaths && (path = resolve(path)), (normalizePath$1 || pathNeedsCleaning) && (path = cleanPath(path)), path === ".") return "";
+  let needsSeperator = path[path.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+  return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+  return function(filename, directoryPath) {
+    return directoryPath.startsWith(root) ? directoryPath.slice(root.length) + filename : convertSlashes(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) {
+  let { 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) {
+    let relativePath = directoryPath.substring(root.length) || ".";
+    filters.every((filter) => filter(relativePath, !0)) && paths.push(relativePath);
+  };
+}
+var pushDirectory = (directoryPath, paths) => {
+  paths.push(directoryPath || ".");
+}, pushDirectoryFilter = (directoryPath, paths, filters) => {
+  let path = directoryPath || ".";
+  filters.every((filter) => filter(path, !0)) && paths.push(path);
+}, empty$2 = () => {
+};
+function build$6(root, options) {
+  let { includeDirs, filters, relativePaths } = options;
+  return includeDirs ? relativePaths ? filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root) : filters && filters.length ? pushDirectoryFilter : pushDirectory : empty$2;
+}
+var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+  filters.every((filter) => filter(filename, !1)) && counts.files++;
+}, pushFileFilter = (filename, paths, _counts, filters) => {
+  filters.every((filter) => filter(filename, !1)) && paths.push(filename);
+}, pushFileCount = (_filename, _paths, counts, _filters) => {
+  counts.files++;
+}, pushFile = (filename, paths) => {
+  paths.push(filename);
+}, empty$1 = () => {
+};
+function build$5(options) {
+  let { excludeFiles, filters, onlyCounts } = options;
+  return excludeFiles ? empty$1 : filters && filters.length ? onlyCounts ? pushFileFilterAndCount : pushFileFilter : onlyCounts ? pushFileCount : pushFile;
+}
+var getArray = (paths) => paths, getArrayGroup = () => [""].slice(0, 0);
+function build$4(options) {
+  return options.group ? getArrayGroup : getArray;
+}
+var groupFiles = (groups, directory, files) => {
+  groups.push({
+    directory,
+    files,
+    dir: directory
+  });
+}, empty = () => {
+};
+function build$3(options) {
+  return options.group ? groupFiles : empty;
+}
+var resolveSymlinksAsync = function(path, state, callback$1) {
+  let { queue, fs, options: { suppressErrors } } = state;
+  queue.enqueue(), fs.realpath(path, (error, resolvedPath) => {
+    if (error) return queue.dequeue(suppressErrors ? null : error, state);
+    fs.stat(resolvedPath, (error$1, stat2) => {
+      if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+      if (stat2.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+      callback$1(stat2, resolvedPath), queue.dequeue(null, state);
+    });
+  });
+}, resolveSymlinks = function(path, state, callback$1) {
+  let { queue, fs, options: { suppressErrors } } = state;
+  queue.enqueue();
+  try {
+    let resolvedPath = fs.realpathSync(path), stat2 = fs.statSync(resolvedPath);
+    if (stat2.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+    callback$1(stat2, resolvedPath);
+  } catch (e) {
+    if (!suppressErrors) throw e;
+  }
+};
+function build$2(options, isSynchronous) {
+  return !options.resolveSymlinks || options.excludeSymlinks ? null : isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+  if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+  let parent = dirname(path), depth = 1;
+  for (; parent !== state.root && depth < 2; ) {
+    let resolvedPath = state.symlinks.get(parent);
+    !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)) ? depth++ : parent = dirname(parent);
+  }
+  return state.symlinks.set(path, resolved), depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+  return state.visited.includes(resolved + state.options.pathSeparator);
+}
+var onlyCountsSync = (state) => state.counts, groupsSync = (state) => state.groups, defaultSync = (state) => state.paths, limitFilesSync = (state) => state.paths.slice(0, state.options.maxFiles), onlyCountsAsync = (state, error, callback$1) => (report(error, callback$1, state.counts, state.options.suppressErrors), null), defaultAsync = (state, error, callback$1) => (report(error, callback$1, state.paths, state.options.suppressErrors), null), limitFilesAsync = (state, error, callback$1) => (report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors), null), groupsAsync = (state, error, callback$1) => (report(error, callback$1, state.groups, state.options.suppressErrors), null);
+function report(error, callback$1, output, suppressErrors) {
+  callback$1(error && !suppressErrors ? error : null, output);
+}
+function build$1(options, isSynchronous) {
+  let { onlyCounts, group, maxFiles } = options;
+  return onlyCounts ? isSynchronous ? onlyCountsSync : onlyCountsAsync : group ? isSynchronous ? groupsSync : groupsAsync : maxFiles ? isSynchronous ? limitFilesSync : limitFilesAsync : isSynchronous ? defaultSync : defaultAsync;
+}
+var readdirOpts = { withFileTypes: !0 }, walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+  if (state.queue.enqueue(), currentDepth < 0) return state.queue.dequeue(null, state);
+  let { fs } = state;
+  state.visited.push(crawlPath), state.counts.directories++, fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+    callback$1(entries, directoryPath, currentDepth), state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+  });
+}, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+  let { fs } = state;
+  if (currentDepth < 0) return;
+  state.visited.push(crawlPath), state.counts.directories++;
+  let entries = [];
+  try {
+    entries = fs.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() {
+    return this.count++, this.count;
+  }
+  dequeue(error, output) {
+    this.onQueueEmpty && (--this.count <= 0 || error) && (this.onQueueEmpty(error, output), error && (output.controller.abort(), this.onQueueEmpty = void 0));
+  }
+}, 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;
+  }
+}, Aborter = class {
+  aborted = !1;
+  abort() {
+    this.aborted = !0;
+  }
+}, 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 || nativeFs
+    }, 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() {
+    return 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), this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+  }
+  walk = (entries, directoryPath, depth) => {
+    let { 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;
+    let files = this.getArray(this.state.paths);
+    for (let i = 0; i < entries.length; ++i) {
+      let entry = entries[i];
+      if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+        let filename = this.joinPath(entry.name, directoryPath);
+        this.pushFile(filename, files, this.state.counts, filters);
+      } else if (entry.isDirectory()) {
+        let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path)) continue;
+        this.pushDirectory(path, paths, filters), this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+      } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+        let path = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path, this.state, (stat2, resolvedPath) => {
+          if (stat2.isDirectory()) {
+            if (resolvedPath = normalizePath(resolvedPath, this.state.options), 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;
+            let filename = basename(resolvedPath), directoryPath$1 = normalizePath(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) {
+  new Walker(root, options, callback$1).start();
+}
+function sync(root, options) {
+  return new Walker(root, options).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);
+  }
+}, pm = null;
+try {
+  __require.resolve("picomatch"), pm = __require("picomatch");
+} catch {
+}
+var Builder = class {
+  globCache = {};
+  options = {
+    maxDepth: 1 / 0,
+    suppressErrors: !0,
+    pathSeparator: sep,
+    filters: []
+  };
+  globFunction;
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    }, this.globFunction = this.options.globFunction;
+  }
+  group() {
+    return this.options.group = !0, this;
+  }
+  withPathSeparator(separator) {
+    return this.options.pathSeparator = separator, this;
+  }
+  withBasePath() {
+    return this.options.includeBasePath = !0, this;
+  }
+  withRelativePaths() {
+    return this.options.relativePaths = !0, this;
+  }
+  withDirs() {
+    return this.options.includeDirs = !0, this;
+  }
+  withMaxDepth(depth) {
+    return this.options.maxDepth = depth, this;
+  }
+  withMaxFiles(limit) {
+    return this.options.maxFiles = limit, this;
+  }
+  withFullPaths() {
+    return this.options.resolvePaths = !0, this.options.includeBasePath = !0, this;
+  }
+  withErrors() {
+    return this.options.suppressErrors = !1, this;
+  }
+  withSymlinks({ resolvePaths = !0 } = {}) {
+    return this.options.resolveSymlinks = !0, this.options.useRealPaths = resolvePaths, this.withFullPaths();
+  }
+  withAbortSignal(signal) {
+    return this.options.signal = signal, this;
+  }
+  normalize() {
+    return this.options.normalizePath = !0, this;
+  }
+  filter(predicate) {
+    return this.options.filters.push(predicate), this;
+  }
+  onlyDirs() {
+    return this.options.excludeFiles = !0, this.options.includeDirs = !0, this;
+  }
+  exclude(predicate) {
+    return this.options.exclude = predicate, this;
+  }
+  onlyCounts() {
+    return this.options.onlyCounts = !0, this;
+  }
+  crawl(root) {
+    return new APIBuilder(root || ".", this.options);
+  }
+  withGlobFunction(fn) {
+    return this.globFunction = fn, this;
+  }
+  /**
+  * @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) {
+    return this.options = {
+      ...this.options,
+      ...options
+    }, new APIBuilder(root || ".", this.options);
+  }
+  glob(...patterns) {
+    return this.globFunction ? this.globWithOptions(patterns) : this.globWithOptions(patterns, { dot: !0 });
+  }
+  globWithOptions(patterns, ...options) {
+    let globFn = this.globFunction || pm;
+    if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+    var isMatch = this.globCache[patterns.join("\0")];
+    return isMatch || (isMatch = globFn(patterns, ...options), this.globCache[patterns.join("\0")] = isMatch), this.options.filters.push((path) => isMatch(path)), this;
+  }
+};
+
+// ../../node_modules/tinyglobby/dist/index.mjs
+var import_picomatch = __toESM(require_picomatch(), 1), isReadonlyArray = Array.isArray, BACKSLASHES = /\\/g, DRIVE_RELATIVE_PATH = /^[A-Za-z]:$/, isWin = process.platform === "win32", ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+  let patternsCount = patterns.length, patternsParts = Array(patternsCount), matchers = Array(patternsCount), i, j;
+  for (i = 0; i < patternsCount; i++) {
+    let parts = splitPattern(patterns[i]);
+    patternsParts[i] = parts;
+    let partsCount = parts.length, partMatchers = Array(partsCount);
+    for (j = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
+    matchers[i] = partMatchers;
+  }
+  return (input) => {
+    let inputParts = input.split("/");
+    if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return !0;
+    for (i = 0; i < patternsCount; i++) {
+      let patternParts = patternsParts[i], matcher = matchers[i], inputPatternCount = inputParts.length, minParts = Math.min(inputPatternCount, patternParts.length);
+      for (j = 0; j < minParts; ) {
+        let part = patternParts[j];
+        if (part.includes("/")) return !0;
+        if (!matcher[j](inputParts[j])) break;
+        if (!options.noglobstar && part === "**") return !0;
+        j++;
+      }
+      if (j === inputPatternCount) return !0;
+    }
+    return !1;
+  };
+}
+var WIN32_ROOT_DIR = /^[A-Z]:\/$/i, isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
+function buildFormat(cwd, root, absolute) {
+  if (cwd === root || root.startsWith(`${cwd}/`)) {
+    if (absolute) {
+      let start = cwd.length + +!isRoot(cwd);
+      return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
+    }
+    let prefix = root.slice(cwd.length + 1);
+    return prefix ? (p, isDir) => {
+      if (p === ".") return prefix;
+      let result = `${prefix}/${p}`;
+      return isDir ? result.slice(0, -1) : result;
+    } : (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
+  }
+  return absolute ? (p) => posix.relative(cwd, p) || "." : (p) => posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+  if (root.startsWith(`${cwd}/`)) {
+    let prefix = root.slice(cwd.length + 1);
+    return (p) => `${prefix}/${p}`;
+  }
+  return (p) => {
+    let result = posix.relative(cwd, `${root}/${p}`);
+    return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
+  };
+}
+function ensureNonDriveRelativePath(path) {
+  return path.replace(DRIVE_RELATIVE_PATH, (match) => `${match}/`);
+}
+var splitPatternOptions = { parts: !0 };
+function splitPattern(path) {
+  var _result$parts;
+  let result = import_picomatch.default.scan(path, splitPatternOptions);
+  return !((_result$parts = result.parts) === null || _result$parts === void 0) && _result$parts.length ? result.parts : [path];
+}
+var ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path) {
+  return escapePosixPath(path);
+}
+function convertWin32PathToPattern(path) {
+  return escapeWin32Path(path).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+var convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern, POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g, WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g, escapePosixPath = (path) => path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path) => path.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath = isWin ? escapeWin32Path : escapePosixPath;
+function isDynamicPattern(pattern, options) {
+  if (options?.caseSensitiveMatch === !1) return !0;
+  let scan = import_picomatch.default.scan(pattern);
+  return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
+}
+function ensureStringArray(value) {
+  return typeof value == "string" ? [value] : value ?? [];
+}
+var PARENT_DIRECTORY = /^(\/?\.\.)+/, ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+function normalizePattern(pattern, opts, props, isIgnore) {
+  var _PARENT_DIRECTORY$exe;
+  let cwd = opts.cwd, result = pattern;
+  pattern[pattern.length - 1] === "/" && (result = pattern.slice(0, -1)), result[result.length - 1] !== "*" && opts.expandDirectories && (result += "/**");
+  let escapedCwd = escapePath(cwd);
+  result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+  let parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0], parts = splitPattern(result);
+  if (parentDir) {
+    let n = (parentDir.length + 1) / 3, i = 0, cwdParts = escapedCwd.split("/");
+    for (; i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]; )
+      result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".", i++;
+    let potentialRoot = posix.join(cwd, parentDir.slice(i * 3));
+    potentialRoot[0] !== "." && props.root.length > potentialRoot.length && (props.root = ensureNonDriveRelativePath(potentialRoot), props.depthOffset = -n + i);
+  }
+  if (!isIgnore && props.depthOffset >= 0) {
+    var _props$commonPath;
+    (_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+    let newCommonPath = [], length = Math.min(props.commonPath.length, parts.length);
+    for (let i = 0; i < length; i++) {
+      let part = parts[i];
+      if (part === "**" && !parts[i + 1]) {
+        newCommonPath.pop();
+        break;
+      }
+      if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
+      newCommonPath.push(part);
+    }
+    props.depthOffset = newCommonPath.length, props.commonPath = newCommonPath, props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd);
+  }
+  return result;
+}
+function processPatterns(options, patterns, props) {
+  let matchPatterns = [], ignorePatterns = [];
+  for (let pattern of options.ignore)
+    pattern && (pattern[0] !== "!" || pattern[1] === "(") && ignorePatterns.push(normalizePattern(pattern, options, props, !0));
+  for (let pattern of patterns)
+    pattern && (pattern[0] !== "!" || pattern[1] === "(" ? matchPatterns.push(normalizePattern(pattern, options, props, !1)) : (pattern[1] !== "!" || pattern[2] === "(") && ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, !0)));
+  return {
+    match: matchPatterns,
+    ignore: ignorePatterns
+  };
+}
+function buildCrawler(options, patterns) {
+  let cwd = options.cwd, props = {
+    root: cwd,
+    depthOffset: 0
+  }, processed = processPatterns(options, patterns, props);
+  options.debug && log("internal processing patterns:", processed);
+  let { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options, root = props.root.replace(BACKSLASHES, ""), matchOptions = {
+    dot,
+    nobrace: options.braceExpansion === !1,
+    nocase: !caseSensitiveMatch,
+    noextglob: options.extglob === !1,
+    noglobstar: options.globstar === !1,
+    posix: !0
+  }, matcher = (0, import_picomatch.default)(processed.match, matchOptions), ignore = (0, import_picomatch.default)(processed.ignore, matchOptions), partialMatcher = getPartialMatcher(processed.match, matchOptions), format = buildFormat(cwd, root, absolute), excludeFormatter = absolute ? format : buildFormat(cwd, root, !0), excludePredicate = (_, p) => {
+    let relativePath = excludeFormatter(p, !0);
+    return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+  }, maxDepth;
+  options.deep !== void 0 && (maxDepth = Math.round(options.deep - props.depthOffset));
+  let crawler = new Builder({
+    filters: [debug ? (p, isDirectory) => {
+      let path = format(p, isDirectory), matches = matcher(path) && !ignore(path);
+      return matches && log(`matched ${path}`), matches;
+    } : (p, isDirectory) => {
+      let path = format(p, isDirectory);
+      return matcher(path) && !ignore(path);
+    }],
+    exclude: debug ? (_, p) => {
+      let skipped = excludePredicate(_, p);
+      return log(`${skipped ? "skipped" : "crawling"} ${p}`), skipped;
+    } : excludePredicate,
+    fs: options.fs,
+    pathSeparator: "/",
+    relativePaths: !absolute,
+    resolvePaths: absolute,
+    includeBasePath: absolute,
+    resolveSymlinks: followSymbolicLinks,
+    excludeSymlinks: !followSymbolicLinks,
+    excludeFiles: onlyDirectories,
+    includeDirs: onlyDirectories || !options.onlyFiles,
+    maxDepth,
+    signal: options.signal
+  }).crawl(root);
+  return options.debug && log("internal properties:", {
+    ...props,
+    root
+  }), [crawler, cwd !== root && !absolute && buildRelative(cwd, root)];
+}
+function formatPaths(paths, mapper) {
+  if (mapper) for (let i = paths.length - 1; i >= 0; i--) paths[i] = mapper(paths[i]);
+  return paths;
+}
+var defaultOptions = {
+  caseSensitiveMatch: !0,
+  debug: !!process.env.TINYGLOBBY_DEBUG,
+  expandDirectories: !0,
+  followSymbolicLinks: !0,
+  onlyFiles: !0
+};
+function getOptions(options) {
+  let opts = Object.assign({}, options);
+  for (let key in defaultOptions) opts[key] === void 0 && Object.assign(opts, { [key]: defaultOptions[key] });
+  return opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve2(opts.cwd || process.cwd())).replace(BACKSLASHES, "/"), opts.ignore = ensureStringArray(opts.ignore), opts.fs && (opts.fs = {
+    readdir: opts.fs.readdir || readdir,
+    readdirSync: opts.fs.readdirSync || readdirSync,
+    realpath: opts.fs.realpath || realpath,
+    realpathSync: opts.fs.realpathSync || realpathSync,
+    stat: opts.fs.stat || stat,
+    statSync: opts.fs.statSync || statSync
+  }), opts.debug && log("globbing with options:", opts), opts;
+}
+function getCrawler(globInput, inputOptions = {}) {
+  var _ref;
+  if (globInput && inputOptions?.patterns) throw new Error("Cannot pass patterns as both an argument and an option");
+  let isModern = isReadonlyArray(globInput) || typeof globInput == "string", patterns = ensureStringArray((_ref = isModern ? globInput : globInput.patterns) !== null && _ref !== void 0 ? _ref : "**/*"), options = getOptions(isModern ? inputOptions : globInput);
+  return patterns.length > 0 ? buildCrawler(options, patterns) : [];
+}
+async function glob(globInput, options) {
+  let [crawler, relative2] = getCrawler(globInput, options);
+  return crawler ? formatPaths(await crawler.withPromise(), relative2) : [];
+}
+function globSync(globInput, options) {
+  let [crawler, relative2] = getCrawler(globInput, options);
+  return crawler ? formatPaths(crawler.sync(), relative2) : [];
+}
+
+export {
+  convertPathToPattern,
+  escapePath,
+  isDynamicPattern,
+  glob,
+  globSync
+};

package/dist/_node-chunks/{chunk-KZBZYQTZ.js → chunk-YHH57LHY.js}

@@ -1,23 +1,23 @@
-import CJS_COMPAT_NODE_URL_ubhjlnocuxr from 'node:url';
-import CJS_COMPAT_NODE_PATH_ubhjlnocuxr from 'node:path';
-import CJS_COMPAT_NODE_MODULE_ubhjlnocuxr from "node:module";
+import CJS_COMPAT_NODE_URL_7qov04rgzsv from 'node:url';
+import CJS_COMPAT_NODE_PATH_7qov04rgzsv from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7qov04rgzsv from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_ubhjlnocuxr.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_ubhjlnocuxr.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_ubhjlnocuxr.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_7qov04rgzsv.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7qov04rgzsv.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7qov04rgzsv.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Forkbook's esbuild configuration
 // ------------------------------------------------------------
 import {
   ADDON_ID2 as ADDON_ID
-} from "./chunk-LGUMVMBA.js";
+} from "./chunk-TN3ULFFZ.js";
 import {
   require_picocolors
-} from "./chunk-ESZVID7Q.js";
+} from "./chunk-MQFB44YS.js";
 import {
   __toESM
-} from "./chunk-WS367FSJ.js";
+} from "./chunk-A35J7YYA.js";
 
 // src/addon-vitest/logger.ts
 var import_picocolors = __toESM(require_picocolors(), 1);

package/dist/_node-chunks/{chunk-J3M3X7GO.js → chunk-YMZ2SGFK.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_ubhjlnocuxr from 'node:url';
-import CJS_COMPAT_NODE_PATH_ubhjlnocuxr from 'node:path';
-import CJS_COMPAT_NODE_MODULE_ubhjlnocuxr from "node:module";
+import CJS_COMPAT_NODE_URL_7qov04rgzsv from 'node:url';
+import CJS_COMPAT_NODE_PATH_7qov04rgzsv from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7qov04rgzsv from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_ubhjlnocuxr.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_ubhjlnocuxr.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_ubhjlnocuxr.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_7qov04rgzsv.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7qov04rgzsv.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7qov04rgzsv.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Forkbook's esbuild configuration