tinker-token-usage 0.1.3 → 0.1.5

package/dist/preload/index-WZEj_JlS.mjs

@@ -0,0 +1,1680 @@
+var he = Object.defineProperty;
+var ge = (t, s, e) => s in t ? he(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var N = (t, s, e) => ge(t, typeof s != "symbol" ? s + "" : s, e);
+import * as de from "fs";
+import { statSync as ye, stat as Ae, realpathSync as Re, realpath as _e, readdirSync as Ee, readdir as Se } from "fs";
+import { sep as Gt, basename as be, dirname as bt, resolve as Wt, normalize as me, relative as xe, posix as tt, isAbsolute as Ce } from "path";
+import { fileURLToPath as $e } from "url";
+import { createRequire as ve } from "module";
+var Ht = /* @__PURE__ */ ve(import.meta.url);
+function we(t) {
+  let s = me(t);
+  return s.length > 1 && s[s.length - 1] === Gt && (s = s.substring(0, s.length - 1)), s;
+}
+const Oe = /[\\/]/g;
+function Ut(t, s) {
+  return t.replace(Oe, s);
+}
+const He = /^[a-z]:[\\/]$/i;
+function Le(t) {
+  return t === "/" || He.test(t);
+}
+function yt(t, s) {
+  const { resolvePaths: e, normalizePath: r, pathSeparator: o } = s, n = process.platform === "win32" && t.includes("/") || t.startsWith(".");
+  if (e && (t = Wt(t)), (r || n) && (t = we(t)), t === ".") return "";
+  const i = t[t.length - 1] !== o;
+  return Ut(i ? t + o : t, o);
+}
+function qt(t, s) {
+  return s + t;
+}
+function Te(t, s) {
+  return function(e, r) {
+    return r.startsWith(t) ? r.slice(t.length) + e : Ut(xe(t, r), s.pathSeparator) + s.pathSeparator + e;
+  };
+}
+function ke(t) {
+  return t;
+}
+function Pe(t, s, e) {
+  return s + t + e;
+}
+function De(t, s) {
+  const { relativePaths: e, includeBasePath: r } = s;
+  return e && t ? Te(t, s) : r ? qt : ke;
+}
+function Ie(t) {
+  return function(s, e) {
+    e.push(s.substring(t.length) || ".");
+  };
+}
+function Ne(t) {
+  return function(s, e, r) {
+    const o = s.substring(t.length) || ".";
+    r.every((n) => n(o, !0)) && e.push(o);
+  };
+}
+const Be = (t, s) => {
+  s.push(t || ".");
+}, Fe = (t, s, e) => {
+  const r = t || ".";
+  e.every((o) => o(r, !0)) && s.push(r);
+}, Me = () => {
+};
+function Ge(t, s) {
+  const { includeDirs: e, filters: r, relativePaths: o } = s;
+  return e ? o ? r && r.length ? Ne(t) : Ie(t) : r && r.length ? Fe : Be : Me;
+}
+const We = (t, s, e, r) => {
+  r.every((o) => o(t, !1)) && e.files++;
+}, Ue = (t, s, e, r) => {
+  r.every((o) => o(t, !1)) && s.push(t);
+}, qe = (t, s, e, r) => {
+  e.files++;
+}, Ke = (t, s) => {
+  s.push(t);
+}, Xe = () => {
+};
+function je(t) {
+  const { excludeFiles: s, filters: e, onlyCounts: r } = t;
+  return s ? Xe : e && e.length ? r ? We : Ue : r ? qe : Ke;
+}
+const Qe = (t) => t, ze = () => [""].slice(0, 0);
+function Ye(t) {
+  return t.group ? ze : Qe;
+}
+const Ze = (t, s, e) => {
+  t.push({
+    directory: s,
+    files: e,
+    dir: s
+  });
+}, Ve = () => {
+};
+function Je(t) {
+  return t.group ? Ze : Ve;
+}
+const ts = function(t, s, e) {
+  const { queue: r, fs: o, options: { suppressErrors: n } } = s;
+  r.enqueue(), o.realpath(t, (i, l) => {
+    if (i) return r.dequeue(n ? null : i, s);
+    o.stat(l, (h, g) => {
+      if (h) return r.dequeue(n ? null : h, s);
+      if (g.isDirectory() && Kt(t, l, s)) return r.dequeue(null, s);
+      e(g, l), r.dequeue(null, s);
+    });
+  });
+}, es = function(t, s, e) {
+  const { queue: r, fs: o, options: { suppressErrors: n } } = s;
+  r.enqueue();
+  try {
+    const i = o.realpathSync(t), l = o.statSync(i);
+    if (l.isDirectory() && Kt(t, i, s)) return;
+    e(l, i);
+  } catch (i) {
+    if (!n) throw i;
+  }
+};
+function ss(t, s) {
+  return !t.resolveSymlinks || t.excludeSymlinks ? null : s ? es : ts;
+}
+function Kt(t, s, e) {
+  if (e.options.useRealPaths) return ns(s, e);
+  let r = bt(t), o = 1;
+  for (; r !== e.root && o < 2; ) {
+    const n = e.symlinks.get(r);
+    !!n && (n === s || n.startsWith(s) || s.startsWith(n)) ? o++ : r = bt(r);
+  }
+  return e.symlinks.set(t, s), o > 1;
+}
+function ns(t, s) {
+  return s.visited.includes(t + s.options.pathSeparator);
+}
+const rs = (t) => t.counts, os = (t) => t.groups, is = (t) => t.paths, us = (t) => t.paths.slice(0, t.options.maxFiles), as = (t, s, e) => (ht(s, e, t.counts, t.options.suppressErrors), null), cs = (t, s, e) => (ht(s, e, t.paths, t.options.suppressErrors), null), ls = (t, s, e) => (ht(s, e, t.paths.slice(0, t.options.maxFiles), t.options.suppressErrors), null), fs = (t, s, e) => (ht(s, e, t.groups, t.options.suppressErrors), null);
+function ht(t, s, e, r) {
+  s(t && !r ? t : null, e);
+}
+function ps(t, s) {
+  const { onlyCounts: e, group: r, maxFiles: o } = t;
+  return e ? s ? rs : as : r ? s ? os : fs : o ? s ? us : ls : s ? is : cs;
+}
+const Xt = { withFileTypes: !0 }, hs = (t, s, e, r, o) => {
+  if (t.queue.enqueue(), r < 0) return t.queue.dequeue(null, t);
+  const { fs: n } = t;
+  t.visited.push(s), t.counts.directories++, n.readdir(s || ".", Xt, (i, l = []) => {
+    o(l, e, r), t.queue.dequeue(t.options.suppressErrors ? null : i, t);
+  });
+}, gs = (t, s, e, r, o) => {
+  const { fs: n } = t;
+  if (r < 0) return;
+  t.visited.push(s), t.counts.directories++;
+  let i = [];
+  try {
+    i = n.readdirSync(s || ".", Xt);
+  } catch (l) {
+    if (!t.options.suppressErrors) throw l;
+  }
+  o(i, e, r);
+};
+function ds(t) {
+  return t ? gs : hs;
+}
+var ys = class {
+  constructor(t) {
+    N(this, "count", 0);
+    this.onQueueEmpty = t;
+  }
+  enqueue() {
+    return this.count++, this.count;
+  }
+  dequeue(t, s) {
+    this.onQueueEmpty && (--this.count <= 0 || t) && (this.onQueueEmpty(t, s), t && (s.controller.abort(), this.onQueueEmpty = void 0));
+  }
+}, As = class {
+  constructor() {
+    N(this, "_files", 0);
+    N(this, "_directories", 0);
+  }
+  set files(t) {
+    this._files = t;
+  }
+  get files() {
+    return this._files;
+  }
+  set directories(t) {
+    this._directories = t;
+  }
+  get directories() {
+    return this._directories;
+  }
+  /**
+  * @deprecated use `directories` instead
+  */
+  /* c8 ignore next 3 */
+  get dirs() {
+    return this._directories;
+  }
+}, Rs = class {
+  constructor() {
+    N(this, "aborted", !1);
+  }
+  abort() {
+    this.aborted = !0;
+  }
+}, jt = class {
+  constructor(t, s, e) {
+    N(this, "root");
+    N(this, "isSynchronous");
+    N(this, "state");
+    N(this, "joinPath");
+    N(this, "pushDirectory");
+    N(this, "pushFile");
+    N(this, "getArray");
+    N(this, "groupFiles");
+    N(this, "resolveSymlink");
+    N(this, "walkDirectory");
+    N(this, "callbackInvoker");
+    N(this, "walk", (t, s, e) => {
+      const { paths: r, options: { filters: o, resolveSymlinks: n, excludeSymlinks: i, exclude: l, maxFiles: h, signal: g, useRealPaths: d, pathSeparator: A }, controller: E } = this.state;
+      if (E.aborted || g && g.aborted || h && r.length > h) return;
+      const x = this.getArray(this.state.paths);
+      for (let y = 0; y < t.length; ++y) {
+        const C = t[y];
+        if (C.isFile() || C.isSymbolicLink() && !n && !i) {
+          const T = this.joinPath(C.name, s);
+          this.pushFile(T, x, this.state.counts, o);
+        } else if (C.isDirectory()) {
+          let T = Pe(C.name, s, this.state.options.pathSeparator);
+          if (l && l(C.name, T)) continue;
+          this.pushDirectory(T, r, o), this.walkDirectory(this.state, T, T, e - 1, this.walk);
+        } else if (this.resolveSymlink && C.isSymbolicLink()) {
+          let T = qt(C.name, s);
+          this.resolveSymlink(T, this.state, (W, _) => {
+            if (W.isDirectory()) {
+              if (_ = yt(_, this.state.options), l && l(C.name, d ? _ : T + A)) return;
+              this.walkDirectory(this.state, _, d ? _ : T + A, e - 1, this.walk);
+            } else {
+              _ = d ? _ : T;
+              const M = be(_), j = yt(bt(_), this.state.options);
+              _ = this.joinPath(M, j), this.pushFile(_, x, this.state.counts, o);
+            }
+          });
+        }
+      }
+      this.groupFiles(this.state.groups, s, x);
+    });
+    this.isSynchronous = !e, this.callbackInvoker = ps(s, this.isSynchronous), this.root = yt(t, s), this.state = {
+      root: Le(this.root) ? this.root : this.root.slice(0, -1),
+      paths: [""].slice(0, 0),
+      groups: [],
+      counts: new As(),
+      options: s,
+      queue: new ys((r, o) => this.callbackInvoker(o, r, e)),
+      symlinks: /* @__PURE__ */ new Map(),
+      visited: [""].slice(0, 0),
+      controller: new Rs(),
+      fs: s.fs || de
+    }, this.joinPath = De(this.root, s), this.pushDirectory = Ge(this.root, s), this.pushFile = je(s), this.getArray = Ye(s), this.groupFiles = Je(s), this.resolveSymlink = ss(s, this.isSynchronous), this.walkDirectory = ds(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;
+  }
+};
+function _s(t, s) {
+  return new Promise((e, r) => {
+    Qt(t, s, (o, n) => {
+      if (o) return r(o);
+      e(n);
+    });
+  });
+}
+function Qt(t, s, e) {
+  new jt(t, s, e).start();
+}
+function Es(t, s) {
+  return new jt(t, s).start();
+}
+var Lt = class {
+  constructor(t, s) {
+    this.root = t, this.options = s;
+  }
+  withPromise() {
+    return _s(this.root, this.options);
+  }
+  withCallback(t) {
+    Qt(this.root, this.options, t);
+  }
+  sync() {
+    return Es(this.root, this.options);
+  }
+};
+let zt = null;
+try {
+  Ht.resolve("picomatch"), zt = Ht("picomatch");
+} catch {
+}
+var Ss = class {
+  constructor(t) {
+    N(this, "globCache", {});
+    N(this, "options", {
+      maxDepth: 1 / 0,
+      suppressErrors: !0,
+      pathSeparator: Gt,
+      filters: []
+    });
+    N(this, "globFunction");
+    this.options = {
+      ...this.options,
+      ...t
+    }, this.globFunction = this.options.globFunction;
+  }
+  group() {
+    return this.options.group = !0, this;
+  }
+  withPathSeparator(t) {
+    return this.options.pathSeparator = t, this;
+  }
+  withBasePath() {
+    return this.options.includeBasePath = !0, this;
+  }
+  withRelativePaths() {
+    return this.options.relativePaths = !0, this;
+  }
+  withDirs() {
+    return this.options.includeDirs = !0, this;
+  }
+  withMaxDepth(t) {
+    return this.options.maxDepth = t, this;
+  }
+  withMaxFiles(t) {
+    return this.options.maxFiles = t, this;
+  }
+  withFullPaths() {
+    return this.options.resolvePaths = !0, this.options.includeBasePath = !0, this;
+  }
+  withErrors() {
+    return this.options.suppressErrors = !1, this;
+  }
+  withSymlinks({ resolvePaths: t = !0 } = {}) {
+    return this.options.resolveSymlinks = !0, this.options.useRealPaths = t, this.withFullPaths();
+  }
+  withAbortSignal(t) {
+    return this.options.signal = t, this;
+  }
+  normalize() {
+    return this.options.normalizePath = !0, this;
+  }
+  filter(t) {
+    return this.options.filters.push(t), this;
+  }
+  onlyDirs() {
+    return this.options.excludeFiles = !0, this.options.includeDirs = !0, this;
+  }
+  exclude(t) {
+    return this.options.exclude = t, this;
+  }
+  onlyCounts() {
+    return this.options.onlyCounts = !0, this;
+  }
+  crawl(t) {
+    return new Lt(t || ".", this.options);
+  }
+  withGlobFunction(t) {
+    return this.globFunction = t, 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(t, s) {
+    return this.options = {
+      ...this.options,
+      ...s
+    }, new Lt(t || ".", this.options);
+  }
+  glob(...t) {
+    return this.globFunction ? this.globWithOptions(t) : this.globWithOptions(t, { dot: !0 });
+  }
+  globWithOptions(t, ...s) {
+    const e = this.globFunction || zt;
+    if (!e) throw new Error("Please specify a glob function to use glob matching.");
+    var r = this.globCache[t.join("\0")];
+    return r || (r = e(t, ...s), this.globCache[t.join("\0")] = r), this.options.filters.push((o) => r(o)), this;
+  }
+};
+function bs(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var ct = {};
+const z = "\\\\/", Tt = `[^${z}]`, ms = 0, Y = "\\.", xs = "\\+", Cs = "\\?", gt = "\\/", $s = "(?=.)", Yt = "[^/]", Ct = `(?:${gt}|$)`, Zt = `(?:^|${gt})`, $t = `${Y}{1,2}${Ct}`, vs = `(?!${Y})`, ws = `(?!${Zt}${$t})`, Os = `(?!${Y}{0,1}${Ct})`, Hs = `(?!${$t})`, Ls = `[^.${gt}]`, Ts = `${Yt}*?`, ks = "/", Vt = {
+  DOT_LITERAL: Y,
+  PLUS_LITERAL: xs,
+  QMARK_LITERAL: Cs,
+  SLASH_LITERAL: gt,
+  ONE_CHAR: $s,
+  QMARK: Yt,
+  END_ANCHOR: Ct,
+  DOTS_SLASH: $t,
+  NO_DOT: vs,
+  NO_DOTS: ws,
+  NO_DOT_SLASH: Os,
+  NO_DOTS_SLASH: Hs,
+  QMARK_NO_DOT: Ls,
+  STAR: Ts,
+  START_ANCHOR: Zt,
+  SEP: ks
+}, Ps = {
+  ...Vt,
+  SLASH_LITERAL: `[${z}]`,
+  QMARK: Tt,
+  STAR: `${Tt}*?`,
+  DOTS_SLASH: `${Y}{1,2}(?:[${z}]|$)`,
+  NO_DOT: `(?!${Y})`,
+  NO_DOTS: `(?!(?:^|[${z}])${Y}{1,2}(?:[${z}]|$))`,
+  NO_DOT_SLASH: `(?!${Y}{0,1}(?:[${z}]|$))`,
+  NO_DOTS_SLASH: `(?!${Y}{1,2}(?:[${z}]|$))`,
+  QMARK_NO_DOT: `[^.${z}]`,
+  START_ANCHOR: `(?:^|[${z}])`,
+  END_ANCHOR: `(?:[${z}]|$)`,
+  SEP: "\\"
+}, Ds = {
+  __proto__: null,
+  alnum: "a-zA-Z0-9",
+  alpha: "a-zA-Z",
+  ascii: "\\x00-\\x7F",
+  blank: " \\t",
+  cntrl: "\\x00-\\x1F\\x7F",
+  digit: "0-9",
+  graph: "\\x21-\\x7E",
+  lower: "a-z",
+  print: "\\x20-\\x7E ",
+  punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+  space: " \\t\\r\\n\\v\\f",
+  upper: "A-Z",
+  word: "A-Za-z0-9_",
+  xdigit: "A-Fa-f0-9"
+};
+var dt = {
+  DEFAULT_MAX_EXTGLOB_RECURSION: ms,
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: Ds,
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    __proto__: null,
+    "***": "*",
+    "**/**": "**",
+    "**/**/**": "**"
+  },
+  // Digits
+  CHAR_0: 48,
+  /* 0 */
+  CHAR_9: 57,
+  /* 9 */
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65,
+  /* A */
+  CHAR_LOWERCASE_A: 97,
+  /* a */
+  CHAR_UPPERCASE_Z: 90,
+  /* Z */
+  CHAR_LOWERCASE_Z: 122,
+  /* z */
+  CHAR_LEFT_PARENTHESES: 40,
+  /* ( */
+  CHAR_RIGHT_PARENTHESES: 41,
+  /* ) */
+  CHAR_ASTERISK: 42,
+  /* * */
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38,
+  /* & */
+  CHAR_AT: 64,
+  /* @ */
+  CHAR_BACKWARD_SLASH: 92,
+  /* \ */
+  CHAR_CARRIAGE_RETURN: 13,
+  /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94,
+  /* ^ */
+  CHAR_COLON: 58,
+  /* : */
+  CHAR_COMMA: 44,
+  /* , */
+  CHAR_DOT: 46,
+  /* . */
+  CHAR_DOUBLE_QUOTE: 34,
+  /* " */
+  CHAR_EQUAL: 61,
+  /* = */
+  CHAR_EXCLAMATION_MARK: 33,
+  /* ! */
+  CHAR_FORM_FEED: 12,
+  /* \f */
+  CHAR_FORWARD_SLASH: 47,
+  /* / */
+  CHAR_GRAVE_ACCENT: 96,
+  /* ` */
+  CHAR_HASH: 35,
+  /* # */
+  CHAR_HYPHEN_MINUS: 45,
+  /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60,
+  /* < */
+  CHAR_LEFT_CURLY_BRACE: 123,
+  /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91,
+  /* [ */
+  CHAR_LINE_FEED: 10,
+  /* \n */
+  CHAR_NO_BREAK_SPACE: 160,
+  /* \u00A0 */
+  CHAR_PERCENT: 37,
+  /* % */
+  CHAR_PLUS: 43,
+  /* + */
+  CHAR_QUESTION_MARK: 63,
+  /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62,
+  /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125,
+  /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93,
+  /* ] */
+  CHAR_SEMICOLON: 59,
+  /* ; */
+  CHAR_SINGLE_QUOTE: 39,
+  /* ' */
+  CHAR_SPACE: 32,
+  /*   */
+  CHAR_TAB: 9,
+  /* \t */
+  CHAR_UNDERSCORE: 95,
+  /* _ */
+  CHAR_VERTICAL_LINE: 124,
+  /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+  /* \uFEFF */
+  /**
+   * Create EXTGLOB_CHARS
+   */
+  extglobChars(t) {
+    return {
+      "!": { type: "negate", open: "(?:(?!(?:", close: `))${t.STAR})` },
+      "?": { type: "qmark", open: "(?:", close: ")?" },
+      "+": { type: "plus", open: "(?:", close: ")+" },
+      "*": { type: "star", open: "(?:", close: ")*" },
+      "@": { type: "at", open: "(?:", close: ")" }
+    };
+  },
+  /**
+   * Create GLOB_CHARS
+   */
+  globChars(t) {
+    return t === !0 ? Ps : Vt;
+  }
+};
+(function(t) {
+  const {
+    REGEX_BACKSLASH: s,
+    REGEX_REMOVE_BACKSLASH: e,
+    REGEX_SPECIAL_CHARS: r,
+    REGEX_SPECIAL_CHARS_GLOBAL: o
+  } = dt;
+  t.isObject = (n) => n !== null && typeof n == "object" && !Array.isArray(n), t.hasRegexChars = (n) => r.test(n), t.isRegexChar = (n) => n.length === 1 && t.hasRegexChars(n), t.escapeRegex = (n) => n.replace(o, "\\$1"), t.toPosixSlashes = (n) => n.replace(s, "/"), t.isWindows = () => {
+    if (typeof navigator < "u" && navigator.platform) {
+      const n = navigator.platform.toLowerCase();
+      return n === "win32" || n === "windows";
+    }
+    return typeof process < "u" && process.platform ? process.platform === "win32" : !1;
+  }, t.removeBackslashes = (n) => n.replace(e, (i) => i === "\\" ? "" : i), t.escapeLast = (n, i, l) => {
+    const h = n.lastIndexOf(i, l);
+    return h === -1 ? n : n[h - 1] === "\\" ? t.escapeLast(n, i, h - 1) : `${n.slice(0, h)}\\${n.slice(h)}`;
+  }, t.removePrefix = (n, i = {}) => {
+    let l = n;
+    return l.startsWith("./") && (l = l.slice(2), i.prefix = "./"), l;
+  }, t.wrapOutput = (n, i = {}, l = {}) => {
+    const h = l.contains ? "" : "^", g = l.contains ? "" : "$";
+    let d = `${h}(?:${n})${g}`;
+    return i.negated === !0 && (d = `(?:^(?!${d}).*$)`), d;
+  }, t.basename = (n, { windows: i } = {}) => {
+    const l = n.split(i ? /[\\/]/ : "/"), h = l[l.length - 1];
+    return h === "" ? l[l.length - 2] : h;
+  };
+})(ct);
+const kt = ct, {
+  CHAR_ASTERISK: At,
+  /* * */
+  CHAR_AT: Is,
+  /* @ */
+  CHAR_BACKWARD_SLASH: rt,
+  /* \ */
+  CHAR_COMMA: Ns,
+  /* , */
+  CHAR_DOT: Rt,
+  /* . */
+  CHAR_EXCLAMATION_MARK: _t,
+  /* ! */
+  CHAR_FORWARD_SLASH: Jt,
+  /* / */
+  CHAR_LEFT_CURLY_BRACE: Et,
+  /* { */
+  CHAR_LEFT_PARENTHESES: ft,
+  /* ( */
+  CHAR_LEFT_SQUARE_BRACKET: Bs,
+  /* [ */
+  CHAR_PLUS: Fs,
+  /* + */
+  CHAR_QUESTION_MARK: Pt,
+  /* ? */
+  CHAR_RIGHT_CURLY_BRACE: Ms,
+  /* } */
+  CHAR_RIGHT_PARENTHESES: Dt,
+  /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET: Gs
+  /* ] */
+} = dt, It = (t) => t === Jt || t === rt, Nt = (t) => {
+  t.isPrefix !== !0 && (t.depth = t.isGlobstar ? 1 / 0 : 1);
+}, Ws = (t, s) => {
+  const e = s || {}, r = t.length - 1, o = e.parts === !0 || e.tokens === !0 || e.scanToEnd === !0, n = [], i = [], l = [];
+  let h = t, g = -1, d = 0, A = 0, E = !1, x = !1, y = !1, C = !1, T = !1, W = !1, _ = !1, M = !1, j = !1, k = !1, O = 0, v, R, m = { value: "", depth: 0, isGlob: !1 };
+  const u = () => g >= r, G = () => h.charCodeAt(g + 1), I = () => (v = R, h.charCodeAt(++g));
+  for (; g < r; ) {
+    R = I();
+    let $;
+    if (R === rt) {
+      _ = m.backslashes = !0, R = I(), R === Et && (W = !0);
+      continue;
+    }
+    if (W === !0 || R === Et) {
+      for (O++; u() !== !0 && (R = I()); ) {
+        if (R === rt) {
+          _ = m.backslashes = !0, I();
+          continue;
+        }
+        if (R === Et) {
+          O++;
+          continue;
+        }
+        if (W !== !0 && R === Rt && (R = I()) === Rt) {
+          if (E = m.isBrace = !0, y = m.isGlob = !0, k = !0, o === !0)
+            continue;
+          break;
+        }
+        if (W !== !0 && R === Ns) {
+          if (E = m.isBrace = !0, y = m.isGlob = !0, k = !0, o === !0)
+            continue;
+          break;
+        }
+        if (R === Ms && (O--, O === 0)) {
+          W = !1, E = m.isBrace = !0, k = !0;
+          break;
+        }
+      }
+      if (o === !0)
+        continue;
+      break;
+    }
+    if (R === Jt) {
+      if (n.push(g), i.push(m), m = { value: "", depth: 0, isGlob: !1 }, k === !0) continue;
+      if (v === Rt && g === d + 1) {
+        d += 2;
+        continue;
+      }
+      A = g + 1;
+      continue;
+    }
+    if (e.noext !== !0 && (R === Fs || R === Is || R === At || R === Pt || R === _t) === !0 && G() === ft) {
+      if (y = m.isGlob = !0, C = m.isExtglob = !0, k = !0, R === _t && g === d && (j = !0), o === !0) {
+        let q = 0;
+        for (; u() !== !0 && (R = I()); ) {
+          if (R === rt) {
+            _ = m.backslashes = !0, I();
+            continue;
+          }
+          if (R === ft) {
+            q++;
+            continue;
+          }
+          if (R === Dt && --q === 0) {
+            k = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (R === At) {
+      if (v === At && (T = m.isGlobstar = !0), y = m.isGlob = !0, k = !0, o === !0)
+        continue;
+      break;
+    }
+    if (R === Pt) {
+      if (y = m.isGlob = !0, k = !0, o === !0)
+        continue;
+      break;
+    }
+    if (R === Bs) {
+      for (; u() !== !0 && ($ = I()); ) {
+        if ($ === rt) {
+          _ = m.backslashes = !0, I();
+          continue;
+        }
+        if ($ === Gs) {
+          x = m.isBracket = !0, y = m.isGlob = !0, k = !0;
+          break;
+        }
+      }
+      if (o === !0)
+        continue;
+      break;
+    }
+    if (e.nonegate !== !0 && R === _t && g === d) {
+      M = m.negated = !0, d++;
+      continue;
+    }
+    if (e.noparen !== !0 && R === ft) {
+      if (y = m.isGlob = !0, o === !0) {
+        let U = 1;
+        for (; u() !== !0 && (R = I()); ) {
+          if (R === rt) {
+            _ = m.backslashes = !0, I();
+            continue;
+          }
+          if (R === ft) {
+            U++;
+            continue;
+          }
+          if (R === Dt && --U === 0) {
+            k = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (y === !0) {
+      if (k = !0, o === !0)
+        continue;
+      break;
+    }
+  }
+  e.noext === !0 && (C = !1, y = !1);
+  let P = h, c = "", a = "";
+  d > 0 && (c = h.slice(0, d), h = h.slice(d), A -= d), P && y === !0 && A > 0 ? (P = h.slice(0, A), a = h.slice(A)) : y === !0 ? (P = "", a = h) : P = h, P && P !== "" && P !== "/" && P !== h && It(P.charCodeAt(P.length - 1)) && (P = P.slice(0, -1)), e.unescape === !0 && (a && (a = kt.removeBackslashes(a)), P && _ === !0 && (P = kt.removeBackslashes(P)));
+  const X = {
+    prefix: c,
+    input: t,
+    start: d,
+    base: P,
+    glob: a,
+    isBrace: E,
+    isBracket: x,
+    isGlob: y,
+    isExtglob: C,
+    isGlobstar: T,
+    negated: M,
+    negatedExtglob: j
+  };
+  if (e.tokens === !0 && (X.maxDepth = 0, It(R) || i.push(m), X.tokens = i), e.parts === !0 || e.tokens === !0) {
+    let $;
+    for (let B = 0; B < n.length; B++) {
+      const et = $ !== void 0 ? $ + 1 : d, ot = n[B], V = t.slice(et, ot);
+      e.tokens && (B === 0 && d !== 0 ? (i[B].isPrefix = !0, i[B].value = c) : i[B].value = V, Nt(i[B]), X.maxDepth += i[B].depth), ot >= d && (l.push(V), $ = ot);
+    }
+    const U = $ !== void 0 ? $ + 1 : d, q = t.slice(U);
+    l.push(q), e.tokens && $ && $ + 1 < t.length && (i[i.length - 1].value = q, Nt(i[i.length - 1]), X.maxDepth += i[i.length - 1].depth), X.slashes = n, X.parts = l;
+  }
+  return X;
+};
+var Us = Ws;
+const ut = dt, K = ct, {
+  MAX_LENGTH: pt,
+  POSIX_REGEX_SOURCE: qs,
+  REGEX_NON_SPECIAL_CHARS: Ks,
+  REGEX_SPECIAL_CHARS_BACKREF: Xs,
+  REPLACEMENTS: te
+} = ut, js = (t, s) => {
+  if (typeof s.expandRange == "function")
+    return s.expandRange(...t, s);
+  t.sort();
+  const e = `[${t.join("-")}]`;
+  try {
+    new RegExp(e);
+  } catch {
+    return t.map((o) => K.escapeRegex(o)).join("..");
+  }
+  return e;
+}, nt = (t, s) => `Missing ${t}: "${s}" - use "\\\\${s}" to match literal characters`, ee = (t) => {
+  const s = [];
+  let e = 0, r = 0, o = 0, n = "", i = !1;
+  for (const l of t) {
+    if (i === !0) {
+      n += l, i = !1;
+      continue;
+    }
+    if (l === "\\") {
+      n += l, i = !0;
+      continue;
+    }
+    if (l === '"') {
+      o = o === 1 ? 0 : 1, n += l;
+      continue;
+    }
+    if (o === 0) {
+      if (l === "[")
+        e++;
+      else if (l === "]" && e > 0)
+        e--;
+      else if (e === 0) {
+        if (l === "(")
+          r++;
+        else if (l === ")" && r > 0)
+          r--;
+        else if (l === "|" && r === 0) {
+          s.push(n), n = "";
+          continue;
+        }
+      }
+    }
+    n += l;
+  }
+  return s.push(n), s;
+}, Qs = (t) => {
+  let s = !1;
+  for (const e of t) {
+    if (s === !0) {
+      s = !1;
+      continue;
+    }
+    if (e === "\\") {
+      s = !0;
+      continue;
+    }
+    if (/[?*+@!()[\]{}]/.test(e))
+      return !1;
+  }
+  return !0;
+}, vt = (t) => {
+  let s = t.trim(), e = !0;
+  for (; e === !0; )
+    e = !1, /^@\([^\\()[\]{}|]+\)$/.test(s) && (s = s.slice(2, -1), e = !0);
+  if (Qs(s))
+    return s.replace(/\\(.)/g, "$1");
+}, zs = (t) => {
+  const s = t.map(vt).filter(Boolean);
+  for (let e = 0; e < s.length; e++)
+    for (let r = e + 1; r < s.length; r++) {
+      const o = s[e], n = s[r], i = o[0];
+      if (!(!i || o !== i.repeat(o.length) || n !== i.repeat(n.length)) && (o === n || o.startsWith(n) || n.startsWith(o)))
+        return !0;
+    }
+  return !1;
+}, mt = (t, s = !0) => {
+  if (t[0] !== "+" && t[0] !== "*" || t[1] !== "(")
+    return;
+  let e = 0, r = 0, o = 0, n = !1;
+  for (let i = 1; i < t.length; i++) {
+    const l = t[i];
+    if (n === !0) {
+      n = !1;
+      continue;
+    }
+    if (l === "\\") {
+      n = !0;
+      continue;
+    }
+    if (l === '"') {
+      o = o === 1 ? 0 : 1;
+      continue;
+    }
+    if (o !== 1) {
+      if (l === "[") {
+        e++;
+        continue;
+      }
+      if (l === "]" && e > 0) {
+        e--;
+        continue;
+      }
+      if (!(e > 0)) {
+        if (l === "(") {
+          r++;
+          continue;
+        }
+        if (l === ")" && (r--, r === 0))
+          return s === !0 && i !== t.length - 1 ? void 0 : {
+            type: t[0],
+            body: t.slice(2, i),
+            end: i
+          };
+      }
+    }
+  }
+}, Ys = (t) => `${t.length === 1 ? K.escapeRegex(t[0]) : `[${t.map((e) => K.escapeRegex(e)).join("")}]`}*`, Zs = (t) => {
+  let s = 0;
+  const e = [];
+  for (; s < t.length; ) {
+    const r = mt(t.slice(s), !1);
+    if (!r || r.type !== "*")
+      return;
+    const o = ee(r.body).map((i) => i.trim());
+    if (o.length !== 1)
+      return;
+    const n = vt(o[0]);
+    if (!n || n.length !== 1)
+      return;
+    e.push(n), s += r.end + 1;
+  }
+  if (!(e.length < 1))
+    return e;
+}, Vs = (t) => {
+  let s = 0, e = t.trim(), r = mt(e);
+  for (; r; )
+    s++, e = r.body.trim(), r = mt(e);
+  return s;
+}, Js = (t, s) => {
+  if (s.maxExtglobRecursion === !1)
+    return { risky: !1 };
+  const e = typeof s.maxExtglobRecursion == "number" ? s.maxExtglobRecursion : ut.DEFAULT_MAX_EXTGLOB_RECURSION, r = ee(t).map((l) => l.trim());
+  if (r.length > 1 && (r.some((l) => l === "") || r.some((l) => /^[*?]+$/.test(l)) || zs(r)))
+    return { risky: !0 };
+  const o = [];
+  let n = !1, i = !0;
+  for (const l of r) {
+    const h = Zs(l);
+    if (h) {
+      n = !0, o.push(...h);
+      continue;
+    }
+    const g = vt(l);
+    if (g && g.length === 1) {
+      o.push(g);
+      continue;
+    }
+    if (i = !1, Vs(l) > e)
+      return { risky: !0 };
+  }
+  return n ? i ? { risky: !0, safeOutput: Ys([...new Set(o)]) } : { risky: !0 } : { risky: !1 };
+}, wt = (t, s) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected a string");
+  t = te[t] || t;
+  const e = { ...s }, r = typeof e.maxLength == "number" ? Math.min(pt, e.maxLength) : pt;
+  let o = t.length;
+  if (o > r)
+    throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${r}`);
+  const n = { type: "bos", value: "", output: e.prepend || "" }, i = [n], l = e.capture ? "" : "?:", h = ut.globChars(e.windows), g = ut.extglobChars(h), {
+    DOT_LITERAL: d,
+    PLUS_LITERAL: A,
+    SLASH_LITERAL: E,
+    ONE_CHAR: x,
+    DOTS_SLASH: y,
+    NO_DOT: C,
+    NO_DOT_SLASH: T,
+    NO_DOTS_SLASH: W,
+    QMARK: _,
+    QMARK_NO_DOT: M,
+    STAR: j,
+    START_ANCHOR: k
+  } = h, O = (p) => `(${l}(?:(?!${k}${p.dot ? y : d}).)*?)`, v = e.dot ? "" : C, R = e.dot ? _ : M;
+  let m = e.bash === !0 ? O(e) : j;
+  e.capture && (m = `(${m})`), typeof e.noext == "boolean" && (e.noextglob = e.noext);
+  const u = {
+    input: t,
+    index: -1,
+    start: 0,
+    dot: e.dot === !0,
+    consumed: "",
+    output: "",
+    prefix: "",
+    backtrack: !1,
+    negated: !1,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: !1,
+    tokens: i
+  };
+  t = K.removePrefix(t, u), o = t.length;
+  const G = [], I = [], P = [];
+  let c = n, a;
+  const X = () => u.index === o - 1, $ = u.peek = (p = 1) => t[u.index + p], U = u.advance = () => t[++u.index] || "", q = () => t.slice(u.index + 1), B = (p = "", L = 0) => {
+    u.consumed += p, u.index += L;
+  }, et = (p) => {
+    u.output += p.output != null ? p.output : p.value, B(p.value);
+  }, ot = () => {
+    let p = 1;
+    for (; $() === "!" && ($(2) !== "(" || $(3) === "?"); )
+      U(), u.start++, p++;
+    return p % 2 === 0 ? !1 : (u.negated = !0, u.start++, !0);
+  }, V = (p) => {
+    u[p]++, P.push(p);
+  }, Z = (p) => {
+    u[p]--, P.pop();
+  }, S = (p) => {
+    if (c.type === "globstar") {
+      const L = u.braces > 0 && (p.type === "comma" || p.type === "brace"), f = p.extglob === !0 || G.length && (p.type === "pipe" || p.type === "paren");
+      p.type !== "slash" && p.type !== "paren" && !L && !f && (u.output = u.output.slice(0, -c.output.length), c.type = "star", c.value = "*", c.output = m, u.output += c.output);
+    }
+    if (G.length && p.type !== "paren" && (G[G.length - 1].inner += p.value), (p.value || p.output) && et(p), c && c.type === "text" && p.type === "text") {
+      c.output = (c.output || c.value) + p.value, c.value += p.value;
+      return;
+    }
+    p.prev = c, i.push(p), c = p;
+  }, lt = (p, L) => {
+    const f = { ...g[L], conditions: 1, inner: "" };
+    f.prev = c, f.parens = u.parens, f.output = u.output, f.startIndex = u.index, f.tokensIndex = i.length;
+    const b = (e.capture ? "(" : "") + f.open;
+    V("parens"), S({ type: p, value: L, output: u.output ? "" : x }), S({ type: "paren", extglob: !0, value: U(), output: b }), G.push(f);
+  }, pe = (p) => {
+    const L = t.slice(p.startIndex, u.index + 1), f = t.slice(p.startIndex + 2, u.index), b = Js(f, e);
+    if ((p.type === "plus" || p.type === "star") && b.risky) {
+      const w = b.safeOutput ? (p.output ? "" : x) + (e.capture ? `(${b.safeOutput})` : b.safeOutput) : void 0, Q = i[p.tokensIndex];
+      Q.type = "text", Q.value = L, Q.output = w || K.escapeRegex(L);
+      for (let J = p.tokensIndex + 1; J < i.length; J++)
+        i[J].value = "", i[J].output = "", delete i[J].suffix;
+      u.output = p.output + Q.output, u.backtrack = !0, S({ type: "paren", extglob: !0, value: a, output: "" }), Z("parens");
+      return;
+    }
+    let H = p.close + (e.capture ? ")" : ""), F;
+    if (p.type === "negate") {
+      let w = m;
+      if (p.inner && p.inner.length > 1 && p.inner.includes("/") && (w = O(e)), (w !== m || X() || /^\)+$/.test(q())) && (H = p.close = `)$))${w}`), p.inner.includes("*") && (F = q()) && /^\.[^\\/.]+$/.test(F)) {
+        const Q = wt(F, { ...s, fastpaths: !1 }).output;
+        H = p.close = `)${Q})${w})`;
+      }
+      p.prev.type === "bos" && (u.negatedExtglob = !0);
+    }
+    S({ type: "paren", extglob: !0, value: a, output: H }), Z("parens");
+  };
+  if (e.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(t)) {
+    let p = !1, L = t.replace(Xs, (f, b, H, F, w, Q) => F === "\\" ? (p = !0, f) : F === "?" ? b ? b + F + (w ? _.repeat(w.length) : "") : Q === 0 ? R + (w ? _.repeat(w.length) : "") : _.repeat(H.length) : F === "." ? d.repeat(H.length) : F === "*" ? b ? b + F + (w ? m : "") : m : b ? f : `\\${f}`);
+    return p === !0 && (e.unescape === !0 ? L = L.replace(/\\/g, "") : L = L.replace(/\\+/g, (f) => f.length % 2 === 0 ? "\\\\" : f ? "\\" : "")), L === t && e.contains === !0 ? (u.output = t, u) : (u.output = K.wrapOutput(L, u, s), u);
+  }
+  for (; !X(); ) {
+    if (a = U(), a === "\0")
+      continue;
+    if (a === "\\") {
+      const f = $();
+      if (f === "/" && e.bash !== !0 || f === "." || f === ";")
+        continue;
+      if (!f) {
+        a += "\\", S({ type: "text", value: a });
+        continue;
+      }
+      const b = /^\\+/.exec(q());
+      let H = 0;
+      if (b && b[0].length > 2 && (H = b[0].length, u.index += H, H % 2 !== 0 && (a += "\\")), e.unescape === !0 ? a = U() : a += U(), u.brackets === 0) {
+        S({ type: "text", value: a });
+        continue;
+      }
+    }
+    if (u.brackets > 0 && (a !== "]" || c.value === "[" || c.value === "[^")) {
+      if (e.posix !== !1 && a === ":") {
+        const f = c.value.slice(1);
+        if (f.includes("[") && (c.posix = !0, f.includes(":"))) {
+          const b = c.value.lastIndexOf("["), H = c.value.slice(0, b), F = c.value.slice(b + 2), w = qs[F];
+          if (w) {
+            c.value = H + w, u.backtrack = !0, U(), !n.output && i.indexOf(c) === 1 && (n.output = x);
+            continue;
+          }
+        }
+      }
+      (a === "[" && $() !== ":" || a === "-" && $() === "]") && (a = `\\${a}`), a === "]" && (c.value === "[" || c.value === "[^") && (a = `\\${a}`), e.posix === !0 && a === "!" && c.value === "[" && (a = "^"), c.value += a, et({ value: a });
+      continue;
+    }
+    if (u.quotes === 1 && a !== '"') {
+      a = K.escapeRegex(a), c.value += a, et({ value: a });
+      continue;
+    }
+    if (a === '"') {
+      u.quotes = u.quotes === 1 ? 0 : 1, e.keepQuotes === !0 && S({ type: "text", value: a });
+      continue;
+    }
+    if (a === "(") {
+      V("parens"), S({ type: "paren", value: a });
+      continue;
+    }
+    if (a === ")") {
+      if (u.parens === 0 && e.strictBrackets === !0)
+        throw new SyntaxError(nt("opening", "("));
+      const f = G[G.length - 1];
+      if (f && u.parens === f.parens + 1) {
+        pe(G.pop());
+        continue;
+      }
+      S({ type: "paren", value: a, output: u.parens ? ")" : "\\)" }), Z("parens");
+      continue;
+    }
+    if (a === "[") {
+      if (e.nobracket === !0 || !q().includes("]")) {
+        if (e.nobracket !== !0 && e.strictBrackets === !0)
+          throw new SyntaxError(nt("closing", "]"));
+        a = `\\${a}`;
+      } else
+        V("brackets");
+      S({ type: "bracket", value: a });
+      continue;
+    }
+    if (a === "]") {
+      if (e.nobracket === !0 || c && c.type === "bracket" && c.value.length === 1) {
+        S({ type: "text", value: a, output: `\\${a}` });
+        continue;
+      }
+      if (u.brackets === 0) {
+        if (e.strictBrackets === !0)
+          throw new SyntaxError(nt("opening", "["));
+        S({ type: "text", value: a, output: `\\${a}` });
+        continue;
+      }
+      Z("brackets");
+      const f = c.value.slice(1);
+      if (c.posix !== !0 && f[0] === "^" && !f.includes("/") && (a = `/${a}`), c.value += a, et({ value: a }), e.literalBrackets === !1 || K.hasRegexChars(f))
+        continue;
+      const b = K.escapeRegex(c.value);
+      if (u.output = u.output.slice(0, -c.value.length), e.literalBrackets === !0) {
+        u.output += b, c.value = b;
+        continue;
+      }
+      c.value = `(${l}${b}|${c.value})`, u.output += c.value;
+      continue;
+    }
+    if (a === "{" && e.nobrace !== !0) {
+      V("braces");
+      const f = {
+        type: "brace",
+        value: a,
+        output: "(",
+        outputIndex: u.output.length,
+        tokensIndex: u.tokens.length
+      };
+      I.push(f), S(f);
+      continue;
+    }
+    if (a === "}") {
+      const f = I[I.length - 1];
+      if (e.nobrace === !0 || !f) {
+        S({ type: "text", value: a, output: a });
+        continue;
+      }
+      let b = ")";
+      if (f.dots === !0) {
+        const H = i.slice(), F = [];
+        for (let w = H.length - 1; w >= 0 && (i.pop(), H[w].type !== "brace"); w--)
+          H[w].type !== "dots" && F.unshift(H[w].value);
+        b = js(F, e), u.backtrack = !0;
+      }
+      if (f.comma !== !0 && f.dots !== !0) {
+        const H = u.output.slice(0, f.outputIndex), F = u.tokens.slice(f.tokensIndex);
+        f.value = f.output = "\\{", a = b = "\\}", u.output = H;
+        for (const w of F)
+          u.output += w.output || w.value;
+      }
+      S({ type: "brace", value: a, output: b }), Z("braces"), I.pop();
+      continue;
+    }
+    if (a === "|") {
+      G.length > 0 && G[G.length - 1].conditions++, S({ type: "text", value: a });
+      continue;
+    }
+    if (a === ",") {
+      let f = a;
+      const b = I[I.length - 1];
+      b && P[P.length - 1] === "braces" && (b.comma = !0, f = "|"), S({ type: "comma", value: a, output: f });
+      continue;
+    }
+    if (a === "/") {
+      if (c.type === "dot" && u.index === u.start + 1) {
+        u.start = u.index + 1, u.consumed = "", u.output = "", i.pop(), c = n;
+        continue;
+      }
+      S({ type: "slash", value: a, output: E });
+      continue;
+    }
+    if (a === ".") {
+      if (u.braces > 0 && c.type === "dot") {
+        c.value === "." && (c.output = d);
+        const f = I[I.length - 1];
+        c.type = "dots", c.output += a, c.value += a, f.dots = !0;
+        continue;
+      }
+      if (u.braces + u.parens === 0 && c.type !== "bos" && c.type !== "slash") {
+        S({ type: "text", value: a, output: d });
+        continue;
+      }
+      S({ type: "dot", value: a, output: d });
+      continue;
+    }
+    if (a === "?") {
+      if (!(c && c.value === "(") && e.noextglob !== !0 && $() === "(" && $(2) !== "?") {
+        lt("qmark", a);
+        continue;
+      }
+      if (c && c.type === "paren") {
+        const b = $();
+        let H = a;
+        (c.value === "(" && !/[!=<:]/.test(b) || b === "<" && !/<([!=]|\w+>)/.test(q())) && (H = `\\${a}`), S({ type: "text", value: a, output: H });
+        continue;
+      }
+      if (e.dot !== !0 && (c.type === "slash" || c.type === "bos")) {
+        S({ type: "qmark", value: a, output: M });
+        continue;
+      }
+      S({ type: "qmark", value: a, output: _ });
+      continue;
+    }
+    if (a === "!") {
+      if (e.noextglob !== !0 && $() === "(" && ($(2) !== "?" || !/[!=<:]/.test($(3)))) {
+        lt("negate", a);
+        continue;
+      }
+      if (e.nonegate !== !0 && u.index === 0) {
+        ot();
+        continue;
+      }
+    }
+    if (a === "+") {
+      if (e.noextglob !== !0 && $() === "(" && $(2) !== "?") {
+        lt("plus", a);
+        continue;
+      }
+      if (c && c.value === "(" || e.regex === !1) {
+        S({ type: "plus", value: a, output: A });
+        continue;
+      }
+      if (c && (c.type === "bracket" || c.type === "paren" || c.type === "brace") || u.parens > 0) {
+        S({ type: "plus", value: a });
+        continue;
+      }
+      S({ type: "plus", value: A });
+      continue;
+    }
+    if (a === "@") {
+      if (e.noextglob !== !0 && $() === "(" && $(2) !== "?") {
+        S({ type: "at", extglob: !0, value: a, output: "" });
+        continue;
+      }
+      S({ type: "text", value: a });
+      continue;
+    }
+    if (a !== "*") {
+      (a === "$" || a === "^") && (a = `\\${a}`);
+      const f = Ks.exec(q());
+      f && (a += f[0], u.index += f[0].length), S({ type: "text", value: a });
+      continue;
+    }
+    if (c && (c.type === "globstar" || c.star === !0)) {
+      c.type = "star", c.star = !0, c.value += a, c.output = m, u.backtrack = !0, u.globstar = !0, B(a);
+      continue;
+    }
+    let p = q();
+    if (e.noextglob !== !0 && /^\([^?]/.test(p)) {
+      lt("star", a);
+      continue;
+    }
+    if (c.type === "star") {
+      if (e.noglobstar === !0) {
+        B(a);
+        continue;
+      }
+      const f = c.prev, b = f.prev, H = f.type === "slash" || f.type === "bos", F = b && (b.type === "star" || b.type === "globstar");
+      if (e.bash === !0 && (!H || p[0] && p[0] !== "/")) {
+        S({ type: "star", value: a, output: "" });
+        continue;
+      }
+      const w = u.braces > 0 && (f.type === "comma" || f.type === "brace"), Q = G.length && (f.type === "pipe" || f.type === "paren");
+      if (!H && f.type !== "paren" && !w && !Q) {
+        S({ type: "star", value: a, output: "" });
+        continue;
+      }
+      for (; p.slice(0, 3) === "/**"; ) {
+        const st = t[u.index + 4];
+        if (st && st !== "/")
+          break;
+        p = p.slice(3), B("/**", 3);
+      }
+      const J = X() || u.parens > 0 && p === ")".repeat(u.parens) && !G.some((st) => st.type === "negate");
+      if (f.type === "bos" && X()) {
+        c.type = "globstar", c.value += a, c.output = O(e), u.output = c.output, u.globstar = !0, B(a);
+        continue;
+      }
+      if (f.type === "slash" && f.prev.type !== "bos" && !F && J) {
+        u.output = u.output.slice(0, -(f.output + c.output).length), f.output = `(?:${f.output}`, c.type = "globstar", c.output = O(e) + (e.strictSlashes ? ")" : "|$)"), c.value += a, u.globstar = !0, u.output += f.output + c.output, B(a);
+        continue;
+      }
+      if (f.type === "slash" && f.prev.type !== "bos" && p[0] === "/") {
+        const st = p[1] !== void 0 ? "|$" : "";
+        u.output = u.output.slice(0, -(f.output + c.output).length), f.output = `(?:${f.output}`, c.type = "globstar", c.output = `${O(e)}${E}|${E}${st})`, c.value += a, u.output += f.output + c.output, u.globstar = !0, B(a + U()), S({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      if (f.type === "bos" && p[0] === "/") {
+        c.type = "globstar", c.value += a, c.output = `(?:^|${E}|${O(e)}${E})`, u.output = c.output, u.globstar = !0, B(a + U()), S({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      u.output = u.output.slice(0, -c.output.length), c.type = "globstar", c.output = O(e), c.value += a, u.output += c.output, u.globstar = !0, B(a);
+      continue;
+    }
+    const L = { type: "star", value: a, output: m };
+    if (e.bash === !0) {
+      L.output = ".*?", (c.type === "bos" || c.type === "slash") && (L.output = v + L.output), S(L);
+      continue;
+    }
+    if (c && (c.type === "bracket" || c.type === "paren") && e.regex === !0) {
+      L.output = a, S(L);
+      continue;
+    }
+    (u.index === u.start || c.type === "slash" || c.type === "dot") && (c.type === "dot" ? (u.output += T, c.output += T) : e.dot === !0 ? (u.output += W, c.output += W) : (u.output += v, c.output += v), $() !== "*" && (u.output += x, c.output += x)), S(L);
+  }
+  for (; u.brackets > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(nt("closing", "]"));
+    u.output = K.escapeLast(u.output, "["), Z("brackets");
+  }
+  for (; u.parens > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(nt("closing", ")"));
+    u.output = K.escapeLast(u.output, "("), Z("parens");
+  }
+  for (; u.braces > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(nt("closing", "}"));
+    u.output = K.escapeLast(u.output, "{"), Z("braces");
+  }
+  if (e.strictSlashes !== !0 && (c.type === "star" || c.type === "bracket") && S({ type: "maybe_slash", value: "", output: `${E}?` }), u.backtrack === !0) {
+    u.output = "";
+    for (const p of u.tokens)
+      u.output += p.output != null ? p.output : p.value, p.suffix && (u.output += p.suffix);
+  }
+  return u;
+};
+wt.fastpaths = (t, s) => {
+  const e = { ...s }, r = typeof e.maxLength == "number" ? Math.min(pt, e.maxLength) : pt, o = t.length;
+  if (o > r)
+    throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${r}`);
+  t = te[t] || t;
+  const {
+    DOT_LITERAL: n,
+    SLASH_LITERAL: i,
+    ONE_CHAR: l,
+    DOTS_SLASH: h,
+    NO_DOT: g,
+    NO_DOTS: d,
+    NO_DOTS_SLASH: A,
+    STAR: E,
+    START_ANCHOR: x
+  } = ut.globChars(e.windows), y = e.dot ? d : g, C = e.dot ? A : g, T = e.capture ? "" : "?:", W = { negated: !1, prefix: "" };
+  let _ = e.bash === !0 ? ".*?" : E;
+  e.capture && (_ = `(${_})`);
+  const M = (v) => v.noglobstar === !0 ? _ : `(${T}(?:(?!${x}${v.dot ? h : n}).)*?)`, j = (v) => {
+    switch (v) {
+      case "*":
+        return `${y}${l}${_}`;
+      case ".*":
+        return `${n}${l}${_}`;
+      case "*.*":
+        return `${y}${_}${n}${l}${_}`;
+      case "*/*":
+        return `${y}${_}${i}${l}${C}${_}`;
+      case "**":
+        return y + M(e);
+      case "**/*":
+        return `(?:${y}${M(e)}${i})?${C}${l}${_}`;
+      case "**/*.*":
+        return `(?:${y}${M(e)}${i})?${C}${_}${n}${l}${_}`;
+      case "**/.*":
+        return `(?:${y}${M(e)}${i})?${n}${l}${_}`;
+      default: {
+        const R = /^(.*?)\.(\w+)$/.exec(v);
+        if (!R) return;
+        const m = j(R[1]);
+        return m ? m + n + R[2] : void 0;
+      }
+    }
+  }, k = K.removePrefix(t, W);
+  let O = j(k);
+  return O && e.strictSlashes !== !0 && (O += `${i}?`), O;
+};
+var tn = wt;
+const en = Us, xt = tn, se = ct, sn = dt, nn = (t) => t && typeof t == "object" && !Array.isArray(t), D = (t, s, e = !1) => {
+  if (Array.isArray(t)) {
+    const d = t.map((E) => D(E, s, e));
+    return (E) => {
+      for (const x of d) {
+        const y = x(E);
+        if (y) return y;
+      }
+      return !1;
+    };
+  }
+  const r = nn(t) && t.tokens && t.input;
+  if (t === "" || typeof t != "string" && !r)
+    throw new TypeError("Expected pattern to be a non-empty string");
+  const o = s || {}, n = o.windows, i = r ? D.compileRe(t, s) : D.makeRe(t, s, !1, !0), l = i.state;
+  delete i.state;
+  let h = () => !1;
+  if (o.ignore) {
+    const d = { ...s, ignore: null, onMatch: null, onResult: null };
+    h = D(o.ignore, d, e);
+  }
+  const g = (d, A = !1) => {
+    const { isMatch: E, match: x, output: y } = D.test(d, i, s, { glob: t, posix: n }), C = { glob: t, state: l, regex: i, posix: n, input: d, output: y, match: x, isMatch: E };
+    return typeof o.onResult == "function" && o.onResult(C), E === !1 ? (C.isMatch = !1, A ? C : !1) : h(d) ? (typeof o.onIgnore == "function" && o.onIgnore(C), C.isMatch = !1, A ? C : !1) : (typeof o.onMatch == "function" && o.onMatch(C), A ? C : !0);
+  };
+  return e && (g.state = l), g;
+};
+D.test = (t, s, e, { glob: r, posix: o } = {}) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected input to be a string");
+  if (t === "")
+    return { isMatch: !1, output: "" };
+  const n = e || {}, i = n.format || (o ? se.toPosixSlashes : null);
+  let l = t === r, h = l && i ? i(t) : t;
+  return l === !1 && (h = i ? i(t) : t, l = h === r), (l === !1 || n.capture === !0) && (n.matchBase === !0 || n.basename === !0 ? l = D.matchBase(t, s, e, o) : l = s.exec(h)), { isMatch: !!l, match: l, output: h };
+};
+D.matchBase = (t, s, e, r = e && e.windows) => (s instanceof RegExp ? s : D.makeRe(s, e)).test(se.basename(t, { windows: r }));
+D.isMatch = (t, s, e) => D(s, e)(t);
+D.parse = (t, s) => Array.isArray(t) ? t.map((e) => D.parse(e, s)) : xt(t, { ...s, fastpaths: !1 });
+D.scan = (t, s) => en(t, s);
+D.compileRe = (t, s, e = !1, r = !1) => {
+  if (e === !0)
+    return t.output;
+  const o = s || {}, n = o.contains ? "" : "^", i = o.contains ? "" : "$";
+  let l = `${n}(?:${t.output})${i}`;
+  t && t.negated === !0 && (l = `^(?!${l}).*$`);
+  const h = D.toRegex(l, s);
+  return r === !0 && (h.state = t), h;
+};
+D.makeRe = (t, s = {}, e = !1, r = !1) => {
+  if (!t || typeof t != "string")
+    throw new TypeError("Expected a non-empty string");
+  let o = { negated: !1, fastpaths: !0 };
+  return s.fastpaths !== !1 && (t[0] === "." || t[0] === "*") && (o.output = xt.fastpaths(t, s)), o.output || (o = xt(t, s)), D.compileRe(o, s, e, r);
+};
+D.toRegex = (t, s) => {
+  try {
+    const e = s || {};
+    return new RegExp(t, e.flags || (e.nocase ? "i" : ""));
+  } catch (e) {
+    if (s && s.debug === !0) throw e;
+    return /$^/;
+  }
+};
+D.constants = sn;
+var rn = D;
+const ne = rn, on = ct;
+function re(t, s, e = !1) {
+  return s && (s.windows === null || s.windows === void 0) && (s = { ...s, windows: on.isWindows() }), ne(t, s, e);
+}
+Object.assign(re, ne);
+var un = re;
+const at = /* @__PURE__ */ bs(un), an = Array.isArray, oe = /\\/g, cn = /^[A-Za-z]:$/, Ot = process.platform === "win32", ln = /^(\/?\.\.)+$/;
+function fn(t, s = {}) {
+  const e = t.length, r = Array(e), o = Array(e);
+  let n, i;
+  for (n = 0; n < e; n++) {
+    const l = ie(t[n]);
+    r[n] = l;
+    const h = l.length, g = Array(h);
+    for (i = 0; i < h; i++) g[i] = at(l[i], s);
+    o[n] = g;
+  }
+  return (l) => {
+    const h = l.split("/");
+    if (h[0] === ".." && ln.test(l)) return !0;
+    for (n = 0; n < e; n++) {
+      const g = r[n], d = o[n], A = h.length, E = Math.min(A, g.length);
+      for (i = 0; i < E; ) {
+        const x = g[i];
+        if (x.includes("/")) return !0;
+        if (!d[i](h[i])) break;
+        if (!s.noglobstar && x === "**") return !0;
+        i++;
+      }
+      if (i === A) return !0;
+    }
+    return !1;
+  };
+}
+const pn = /^[A-Z]:\/$/i, hn = Ot ? (t) => pn.test(t) : (t) => t === "/";
+function Bt(t, s, e) {
+  if (t === s || s.startsWith(`${t}/`)) {
+    if (e) {
+      const o = t.length + +!hn(t);
+      return (n, i) => n.slice(o, i ? -1 : void 0) || ".";
+    }
+    const r = s.slice(t.length + 1);
+    return r ? (o, n) => {
+      if (o === ".") return r;
+      const i = `${r}/${o}`;
+      return n ? i.slice(0, -1) : i;
+    } : (o, n) => n && o !== "." ? o.slice(0, -1) : o;
+  }
+  return e ? (r) => tt.relative(t, r) || "." : (r) => tt.relative(t, `${s}/${r}`) || ".";
+}
+function gn(t, s) {
+  if (s.startsWith(`${t}/`)) {
+    const e = s.slice(t.length + 1);
+    return (r) => `${e}/${r}`;
+  }
+  return (e) => {
+    const r = tt.relative(t, `${s}/${e}`);
+    return e[e.length - 1] === "/" && r !== "" ? `${r}/` : r || ".";
+  };
+}
+function Ft(t) {
+  return t.replace(cn, (s) => `${s}/`);
+}
+const dn = { parts: !0 };
+function ie(t) {
+  var s;
+  const e = at.scan(t, dn);
+  return !((s = e.parts) === null || s === void 0) && s.length ? e.parts : [t];
+}
+const yn = /\\(?![()[\]{}!+@])/g;
+function An(t) {
+  return ue(t);
+}
+function Rn(t) {
+  return ae(t).replace(yn, "/");
+}
+const kn = Ot ? Rn : An, _n = new RegExp("(?<!\\\\)([()[\\]{}*?|]|^!|[!+@](?=\\()|\\\\(?![()[\\]{}!*+?@|]))", "g"), En = new RegExp("(?<!\\\\)([()[\\]{}]|^!|[!+@](?=\\())", "g"), ue = (t) => t.replace(_n, "\\$&"), ae = (t) => t.replace(En, "\\$&"), Sn = Ot ? ae : ue;
+function bn(t, s) {
+  if ((s == null ? void 0 : s.caseSensitiveMatch) === !1) return !0;
+  const e = at.scan(t);
+  return e.isGlob || e.negated;
+}
+function it(...t) {
+  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...t);
+}
+function ce(t) {
+  return typeof t == "string" ? [t] : t ?? [];
+}
+const mn = /^(\/?\.\.)+/, xn = /\\(?=[()[\]{}!*+?@|])/g;
+function St(t, s, e, r) {
+  var o;
+  const n = s.cwd;
+  let i = t;
+  t[t.length - 1] === "/" && (i = t.slice(0, -1)), i[i.length - 1] !== "*" && s.expandDirectories && (i += "/**");
+  const l = Sn(n);
+  i = Ce(i.replace(xn, "")) ? tt.relative(l, i) : tt.normalize(i);
+  const h = (o = mn.exec(i)) === null || o === void 0 ? void 0 : o[0], g = ie(i);
+  if (h) {
+    const A = (h.length + 1) / 3;
+    let E = 0;
+    const x = l.split("/");
+    for (; E < A && g[E + A] === x[x.length + E - A]; )
+      i = i.slice(0, (A - E - 1) * 3) + i.slice((A - E) * 3 + g[E + A].length + 1) || ".", E++;
+    const y = tt.join(n, h.slice(E * 3));
+    y[0] !== "." && e.root.length > y.length && (e.root = Ft(y), e.depthOffset = -A + E);
+  }
+  if (!r && e.depthOffset >= 0) {
+    var d;
+    (d = e.commonPath) !== null && d !== void 0 || (e.commonPath = g);
+    const A = [], E = Math.min(e.commonPath.length, g.length);
+    for (let x = 0; x < E; x++) {
+      const y = g[x];
+      if (y === "**" && !g[x + 1]) {
+        A.pop();
+        break;
+      }
+      if (x === g.length - 1 || y !== e.commonPath[x] || bn(y)) break;
+      A.push(y);
+    }
+    e.depthOffset = A.length, e.commonPath = A, e.root = Ft(A.length > 0 ? tt.join(n, ...A) : n);
+  }
+  return i;
+}
+function Cn(t, s, e) {
+  const r = [], o = [];
+  for (const n of t.ignore)
+    n && (n[0] !== "!" || n[1] === "(") && o.push(St(n, t, e, !0));
+  for (const n of s)
+    n && (n[0] !== "!" || n[1] === "(" ? r.push(St(n, t, e, !1)) : (n[1] !== "!" || n[2] === "(") && o.push(St(n.slice(1), t, e, !0)));
+  return {
+    match: r,
+    ignore: o
+  };
+}
+function $n(t, s) {
+  const e = t.cwd, r = {
+    root: e,
+    depthOffset: 0
+  }, o = Cn(t, s, r);
+  t.debug && it("internal processing patterns:", o);
+  const { absolute: n, caseSensitiveMatch: i, debug: l, dot: h, followSymbolicLinks: g, onlyDirectories: d } = t, A = r.root.replace(oe, ""), E = {
+    dot: h,
+    nobrace: t.braceExpansion === !1,
+    nocase: !i,
+    noextglob: t.extglob === !1,
+    noglobstar: t.globstar === !1,
+    posix: !0
+  }, x = at(o.match, E), y = at(o.ignore, E), C = fn(o.match, E), T = Bt(e, A, n), W = n ? T : Bt(e, A, !0), _ = (k, O) => {
+    const v = W(O, !0);
+    return v !== "." && !C(v) || y(v);
+  };
+  let M;
+  t.deep !== void 0 && (M = Math.round(t.deep - r.depthOffset));
+  const j = new Ss({
+    filters: [l ? (k, O) => {
+      const v = T(k, O), R = x(v) && !y(v);
+      return R && it(`matched ${v}`), R;
+    } : (k, O) => {
+      const v = T(k, O);
+      return x(v) && !y(v);
+    }],
+    exclude: l ? (k, O) => {
+      const v = _(k, O);
+      return it(`${v ? "skipped" : "crawling"} ${O}`), v;
+    } : _,
+    fs: t.fs,
+    pathSeparator: "/",
+    relativePaths: !n,
+    resolvePaths: n,
+    includeBasePath: n,
+    resolveSymlinks: g,
+    excludeSymlinks: !g,
+    excludeFiles: d,
+    includeDirs: d || !t.onlyFiles,
+    maxDepth: M,
+    signal: t.signal
+  }).crawl(A);
+  return t.debug && it("internal properties:", {
+    ...r,
+    root: A
+  }), [j, e !== A && !n && gn(e, A)];
+}
+function le(t, s) {
+  if (s) for (let e = t.length - 1; e >= 0; e--) t[e] = s(t[e]);
+  return t;
+}
+const Mt = {
+  caseSensitiveMatch: !0,
+  debug: !!process.env.TINYGLOBBY_DEBUG,
+  expandDirectories: !0,
+  followSymbolicLinks: !0,
+  onlyFiles: !0
+};
+function vn(t) {
+  const s = Object.assign({}, t);
+  for (const e in Mt) s[e] === void 0 && Object.assign(s, { [e]: Mt[e] });
+  return s.cwd = (s.cwd instanceof URL ? $e(s.cwd) : Wt(s.cwd || process.cwd())).replace(oe, "/"), s.ignore = ce(s.ignore), s.fs && (s.fs = {
+    readdir: s.fs.readdir || Se,
+    readdirSync: s.fs.readdirSync || Ee,
+    realpath: s.fs.realpath || _e,
+    realpathSync: s.fs.realpathSync || Re,
+    stat: s.fs.stat || Ae,
+    statSync: s.fs.statSync || ye
+  }), s.debug && it("globbing with options:", s), s;
+}
+function fe(t, s = {}) {
+  var e;
+  if (t && (s != null && s.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+  const r = an(t) || typeof t == "string", o = ce((e = r ? t : t.patterns) !== null && e !== void 0 ? e : "**/*"), n = vn(r ? s : t);
+  return o.length > 0 ? $n(n, o) : [];
+}
+async function Pn(t, s) {
+  const [e, r] = fe(t, s);
+  return e ? le(await e.withPromise(), r) : [];
+}
+function Dn(t, s) {
+  const [e, r] = fe(t, s);
+  return e ? le(e.sync(), r) : [];
+}
+export {
+  kn as convertPathToPattern,
+  Sn as escapePath,
+  Pn as glob,
+  Dn as globSync,
+  bn as isDynamicPattern
+};