tinker-token-usage 0.1.2 → 0.1.4

package/dist/preload/index-Dot49rhx.mjs

@@ -0,0 +1,1672 @@
+var pe = Object.defineProperty;
+var he = (t, s, e) => s in t ? pe(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var B = (t, s, e) => he(t, typeof s != "symbol" ? s + "" : s, e);
+import * as ge from "fs";
+import { statSync as ye, stat as de, realpathSync as Ae, realpath as Re, readdirSync as _e, readdir as Se } from "fs";
+import { sep as Ft, basename as Ee, dirname as St, resolve as Mt, normalize as be, relative as me, posix as tt, isAbsolute as xe } from "path";
+import { fileURLToPath as Ce } from "url";
+import { createRequire as $e } from "module";
+var wt = /* @__PURE__ */ $e(import.meta.url);
+function ve(t) {
+  let s = be(t);
+  return s.length > 1 && s[s.length - 1] === Ft && (s = s.substring(0, s.length - 1)), s;
+}
+const we = /[\\/]/g;
+function Gt(t, s) {
+  return t.replace(we, s);
+}
+const Oe = /^[a-z]:[\\/]$/i;
+function He(t) {
+  return t === "/" || Oe.test(t);
+}
+function ht(t, s) {
+  const { resolvePaths: e, normalizePath: r, pathSeparator: o } = s, n = process.platform === "win32" && t.includes("/") || t.startsWith(".");
+  if (e && (t = Mt(t)), (r || n) && (t = ve(t)), t === ".") return "";
+  const i = t[t.length - 1] !== o;
+  return Gt(i ? t + o : t, o);
+}
+function Wt(t, s) {
+  return s + t;
+}
+function Le(t, s) {
+  return function(e, r) {
+    return r.startsWith(t) ? r.slice(t.length) + e : Gt(me(t, r), s.pathSeparator) + s.pathSeparator + e;
+  };
+}
+function Te(t) {
+  return t;
+}
+function ke(t, s, e) {
+  return s + t + e;
+}
+function Pe(t, s) {
+  const { relativePaths: e, includeBasePath: r } = s;
+  return e && t ? Le(t, s) : r ? Wt : Te;
+}
+function De(t) {
+  return function(s, e) {
+    e.push(s.substring(t.length) || ".");
+  };
+}
+function Ie(t) {
+  return function(s, e, r) {
+    const o = s.substring(t.length) || ".";
+    r.every((n) => n(o, !0)) && e.push(o);
+  };
+}
+const Ne = (t, s) => {
+  s.push(t || ".");
+}, Be = (t, s, e) => {
+  const r = t || ".";
+  e.every((o) => o(r, !0)) && s.push(r);
+}, Fe = () => {
+};
+function Me(t, s) {
+  const { includeDirs: e, filters: r, relativePaths: o } = s;
+  return e ? o ? r && r.length ? Ie(t) : De(t) : r && r.length ? Be : Ne : Fe;
+}
+const Ge = (t, s, e, r) => {
+  r.every((o) => o(t, !1)) && e.files++;
+}, We = (t, s, e, r) => {
+  r.every((o) => o(t, !1)) && s.push(t);
+}, Ue = (t, s, e, r) => {
+  e.files++;
+}, qe = (t, s) => {
+  s.push(t);
+}, Ke = () => {
+};
+function Xe(t) {
+  const { excludeFiles: s, filters: e, onlyCounts: r } = t;
+  return s ? Ke : e && e.length ? r ? Ge : We : r ? Ue : qe;
+}
+const je = (t) => t, Qe = () => [""].slice(0, 0);
+function ze(t) {
+  return t.group ? Qe : je;
+}
+const Ye = (t, s, e) => {
+  t.push({
+    directory: s,
+    files: e,
+    dir: s
+  });
+}, Ze = () => {
+};
+function Ve(t) {
+  return t.group ? Ye : Ze;
+}
+const Je = 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() && Ut(t, l, s)) return r.dequeue(null, s);
+      e(g, l), r.dequeue(null, s);
+    });
+  });
+}, ts = 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() && Ut(t, i, s)) return;
+    e(l, i);
+  } catch (i) {
+    if (!n) throw i;
+  }
+};
+function es(t, s) {
+  return !t.resolveSymlinks || t.excludeSymlinks ? null : s ? ts : Je;
+}
+function Ut(t, s, e) {
+  if (e.options.useRealPaths) return ss(s, e);
+  let r = St(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 = St(r);
+  }
+  return e.symlinks.set(t, s), o > 1;
+}
+function ss(t, s) {
+  return s.visited.includes(t + s.options.pathSeparator);
+}
+const ns = (t) => t.counts, rs = (t) => t.groups, os = (t) => t.paths, is = (t) => t.paths.slice(0, t.options.maxFiles), us = (t, s, e) => (lt(s, e, t.counts, t.options.suppressErrors), null), as = (t, s, e) => (lt(s, e, t.paths, t.options.suppressErrors), null), cs = (t, s, e) => (lt(s, e, t.paths.slice(0, t.options.maxFiles), t.options.suppressErrors), null), ls = (t, s, e) => (lt(s, e, t.groups, t.options.suppressErrors), null);
+function lt(t, s, e, r) {
+  s(t && !r ? t : null, e);
+}
+function fs(t, s) {
+  const { onlyCounts: e, group: r, maxFiles: o } = t;
+  return e ? s ? ns : us : r ? s ? rs : ls : o ? s ? is : cs : s ? os : as;
+}
+const qt = { withFileTypes: !0 }, ps = (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 || ".", qt, (i, l = []) => {
+    o(l, e, r), t.queue.dequeue(t.options.suppressErrors ? null : i, t);
+  });
+}, hs = (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 || ".", qt);
+  } catch (l) {
+    if (!t.options.suppressErrors) throw l;
+  }
+  o(i, e, r);
+};
+function gs(t) {
+  return t ? hs : ps;
+}
+var ys = class {
+  constructor(t) {
+    B(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));
+  }
+}, ds = class {
+  constructor() {
+    B(this, "_files", 0);
+    B(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;
+  }
+}, As = class {
+  constructor() {
+    B(this, "aborted", !1);
+  }
+  abort() {
+    this.aborted = !0;
+  }
+}, Kt = class {
+  constructor(t, s, e) {
+    B(this, "root");
+    B(this, "isSynchronous");
+    B(this, "state");
+    B(this, "joinPath");
+    B(this, "pushDirectory");
+    B(this, "pushFile");
+    B(this, "getArray");
+    B(this, "groupFiles");
+    B(this, "resolveSymlink");
+    B(this, "walkDirectory");
+    B(this, "callbackInvoker");
+    B(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: S } = this.state;
+      if (S.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 = ke(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 = Wt(C.name, s);
+          this.resolveSymlink(T, this.state, (G, _) => {
+            if (G.isDirectory()) {
+              if (_ = ht(_, 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 = Ee(_), X = ht(St(_), this.state.options);
+              _ = this.joinPath(M, X), this.pushFile(_, x, this.state.counts, o);
+            }
+          });
+        }
+      }
+      this.groupFiles(this.state.groups, s, x);
+    });
+    this.isSynchronous = !e, this.callbackInvoker = fs(s, this.isSynchronous), this.root = ht(t, s), this.state = {
+      root: He(this.root) ? this.root : this.root.slice(0, -1),
+      paths: [""].slice(0, 0),
+      groups: [],
+      counts: new ds(),
+      options: s,
+      queue: new ys((r, o) => this.callbackInvoker(o, r, e)),
+      symlinks: /* @__PURE__ */ new Map(),
+      visited: [""].slice(0, 0),
+      controller: new As(),
+      fs: s.fs || ge
+    }, this.joinPath = Pe(this.root, s), this.pushDirectory = Me(this.root, s), this.pushFile = Xe(s), this.getArray = ze(s), this.groupFiles = Ve(s), this.resolveSymlink = es(s, this.isSynchronous), this.walkDirectory = gs(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 Rs(t, s) {
+  return new Promise((e, r) => {
+    Xt(t, s, (o, n) => {
+      if (o) return r(o);
+      e(n);
+    });
+  });
+}
+function Xt(t, s, e) {
+  new Kt(t, s, e).start();
+}
+function _s(t, s) {
+  return new Kt(t, s).start();
+}
+var Ot = class {
+  constructor(t, s) {
+    this.root = t, this.options = s;
+  }
+  withPromise() {
+    return Rs(this.root, this.options);
+  }
+  withCallback(t) {
+    Xt(this.root, this.options, t);
+  }
+  sync() {
+    return _s(this.root, this.options);
+  }
+};
+let jt = null;
+try {
+  wt.resolve("picomatch"), jt = wt("picomatch");
+} catch {
+}
+var Ss = class {
+  constructor(t) {
+    B(this, "globCache", {});
+    B(this, "options", {
+      maxDepth: 1 / 0,
+      suppressErrors: !0,
+      pathSeparator: Ft,
+      filters: []
+    });
+    B(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 Ot(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 Ot(t || ".", this.options);
+  }
+  glob(...t) {
+    return this.globFunction ? this.globWithOptions(t) : this.globWithOptions(t, { dot: !0 });
+  }
+  globWithOptions(t, ...s) {
+    const e = this.globFunction || jt;
+    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 Es(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var it = {};
+const z = "\\\\/", Ht = `[^${z}]`, bs = 0, Z = "\\.", ms = "\\+", xs = "\\?", ft = "\\/", Cs = "(?=.)", Qt = "[^/]", mt = `(?:${ft}|$)`, zt = `(?:^|${ft})`, xt = `${Z}{1,2}${mt}`, $s = `(?!${Z})`, vs = `(?!${zt}${xt})`, ws = `(?!${Z}{0,1}${mt})`, Os = `(?!${xt})`, Hs = `[^.${ft}]`, Ls = `${Qt}*?`, Ts = "/", Yt = {
+  DOT_LITERAL: Z,
+  PLUS_LITERAL: ms,
+  QMARK_LITERAL: xs,
+  SLASH_LITERAL: ft,
+  ONE_CHAR: Cs,
+  QMARK: Qt,
+  END_ANCHOR: mt,
+  DOTS_SLASH: xt,
+  NO_DOT: $s,
+  NO_DOTS: vs,
+  NO_DOT_SLASH: ws,
+  NO_DOTS_SLASH: Os,
+  QMARK_NO_DOT: Hs,
+  STAR: Ls,
+  START_ANCHOR: zt,
+  SEP: Ts
+}, ks = {
+  ...Yt,
+  SLASH_LITERAL: `[${z}]`,
+  QMARK: Ht,
+  STAR: `${Ht}*?`,
+  DOTS_SLASH: `${Z}{1,2}(?:[${z}]|$)`,
+  NO_DOT: `(?!${Z})`,
+  NO_DOTS: `(?!(?:^|[${z}])${Z}{1,2}(?:[${z}]|$))`,
+  NO_DOT_SLASH: `(?!${Z}{0,1}(?:[${z}]|$))`,
+  NO_DOTS_SLASH: `(?!${Z}{1,2}(?:[${z}]|$))`,
+  QMARK_NO_DOT: `[^.${z}]`,
+  START_ANCHOR: `(?:^|[${z}])`,
+  END_ANCHOR: `(?:[${z}]|$)`,
+  SEP: "\\"
+}, Ps = {
+  __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 pt = {
+  DEFAULT_MAX_EXTGLOB_RECURSION: bs,
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: Ps,
+  // 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 ? ks : Yt;
+  }
+};
+(function(t) {
+  const {
+    REGEX_BACKSLASH: s,
+    REGEX_REMOVE_BACKSLASH: e,
+    REGEX_SPECIAL_CHARS: r,
+    REGEX_SPECIAL_CHARS_GLOBAL: o
+  } = pt;
+  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;
+  };
+})(it);
+const Lt = it, {
+  CHAR_ASTERISK: gt,
+  /* * */
+  CHAR_AT: Ds,
+  /* @ */
+  CHAR_BACKWARD_SLASH: st,
+  /* \ */
+  CHAR_COMMA: Is,
+  /* , */
+  CHAR_DOT: yt,
+  /* . */
+  CHAR_EXCLAMATION_MARK: dt,
+  /* ! */
+  CHAR_FORWARD_SLASH: Zt,
+  /* / */
+  CHAR_LEFT_CURLY_BRACE: At,
+  /* { */
+  CHAR_LEFT_PARENTHESES: Rt,
+  /* ( */
+  CHAR_LEFT_SQUARE_BRACKET: Ns,
+  /* [ */
+  CHAR_PLUS: Bs,
+  /* + */
+  CHAR_QUESTION_MARK: Tt,
+  /* ? */
+  CHAR_RIGHT_CURLY_BRACE: Fs,
+  /* } */
+  CHAR_RIGHT_PARENTHESES: kt,
+  /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET: Ms
+  /* ] */
+} = pt, Pt = (t) => t === Zt || t === st, Dt = (t) => {
+  t.isPrefix !== !0 && (t.depth = t.isGlobstar ? 1 / 0 : 1);
+}, Gs = (t, s) => {
+  const e = s || {}, r = t.length - 1, o = e.parts === !0 || e.scanToEnd === !0, n = [], i = [], l = [];
+  let h = t, g = -1, d = 0, A = 0, S = !1, x = !1, y = !1, C = !1, T = !1, G = !1, _ = !1, M = !1, X = !1, P = !1, O = 0, v, R, m = { value: "", depth: 0, isGlob: !1 };
+  const c = () => g >= r, W = () => h.charCodeAt(g + 1), N = () => (v = R, h.charCodeAt(++g));
+  for (; g < r; ) {
+    R = N();
+    let $;
+    if (R === st) {
+      _ = m.backslashes = !0, R = N(), R === At && (G = !0);
+      continue;
+    }
+    if (G === !0 || R === At) {
+      for (O++; c() !== !0 && (R = N()); ) {
+        if (R === st) {
+          _ = m.backslashes = !0, N();
+          continue;
+        }
+        if (R === At) {
+          O++;
+          continue;
+        }
+        if (G !== !0 && R === yt && (R = N()) === yt) {
+          if (S = m.isBrace = !0, y = m.isGlob = !0, P = !0, o === !0)
+            continue;
+          break;
+        }
+        if (G !== !0 && R === Is) {
+          if (S = m.isBrace = !0, y = m.isGlob = !0, P = !0, o === !0)
+            continue;
+          break;
+        }
+        if (R === Fs && (O--, O === 0)) {
+          G = !1, S = m.isBrace = !0, P = !0;
+          break;
+        }
+      }
+      if (o === !0)
+        continue;
+      break;
+    }
+    if (R === Zt) {
+      if (n.push(g), i.push(m), m = { value: "", depth: 0, isGlob: !1 }, P === !0) continue;
+      if (v === yt && g === d + 1) {
+        d += 2;
+        continue;
+      }
+      A = g + 1;
+      continue;
+    }
+    if (e.noext !== !0 && (R === Bs || R === Ds || R === gt || R === Tt || R === dt) === !0 && W() === Rt) {
+      if (y = m.isGlob = !0, C = m.isExtglob = !0, P = !0, R === dt && g === d && (X = !0), o === !0) {
+        for (; c() !== !0 && (R = N()); ) {
+          if (R === st) {
+            _ = m.backslashes = !0, R = N();
+            continue;
+          }
+          if (R === kt) {
+            y = m.isGlob = !0, P = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (R === gt) {
+      if (v === gt && (T = m.isGlobstar = !0), y = m.isGlob = !0, P = !0, o === !0)
+        continue;
+      break;
+    }
+    if (R === Tt) {
+      if (y = m.isGlob = !0, P = !0, o === !0)
+        continue;
+      break;
+    }
+    if (R === Ns) {
+      for (; c() !== !0 && ($ = N()); ) {
+        if ($ === st) {
+          _ = m.backslashes = !0, N();
+          continue;
+        }
+        if ($ === Ms) {
+          x = m.isBracket = !0, y = m.isGlob = !0, P = !0;
+          break;
+        }
+      }
+      if (o === !0)
+        continue;
+      break;
+    }
+    if (e.nonegate !== !0 && R === dt && g === d) {
+      M = m.negated = !0, d++;
+      continue;
+    }
+    if (e.noparen !== !0 && R === Rt) {
+      if (y = m.isGlob = !0, o === !0) {
+        for (; c() !== !0 && (R = N()); ) {
+          if (R === Rt) {
+            _ = m.backslashes = !0, R = N();
+            continue;
+          }
+          if (R === kt) {
+            P = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (y === !0) {
+      if (P = !0, o === !0)
+        continue;
+      break;
+    }
+  }
+  e.noext === !0 && (C = !1, y = !1);
+  let D = h, a = "", u = "";
+  d > 0 && (a = h.slice(0, d), h = h.slice(d), A -= d), D && y === !0 && A > 0 ? (D = h.slice(0, A), u = h.slice(A)) : y === !0 ? (D = "", u = h) : D = h, D && D !== "" && D !== "/" && D !== h && Pt(D.charCodeAt(D.length - 1)) && (D = D.slice(0, -1)), e.unescape === !0 && (u && (u = Lt.removeBackslashes(u)), D && _ === !0 && (D = Lt.removeBackslashes(D)));
+  const q = {
+    prefix: a,
+    input: t,
+    start: d,
+    base: D,
+    glob: u,
+    isBrace: S,
+    isBracket: x,
+    isGlob: y,
+    isExtglob: C,
+    isGlobstar: T,
+    negated: M,
+    negatedExtglob: X
+  };
+  if (e.tokens === !0 && (q.maxDepth = 0, Pt(R) || i.push(m), q.tokens = i), e.parts === !0 || e.tokens === !0) {
+    let $;
+    for (let k = 0; k < n.length; k++) {
+      const Y = $ ? $ + 1 : d, K = n[k], V = t.slice(Y, K);
+      e.tokens && (k === 0 && d !== 0 ? (i[k].isPrefix = !0, i[k].value = a) : i[k].value = V, Dt(i[k]), q.maxDepth += i[k].depth), (k !== 0 || V !== "") && l.push(V), $ = K;
+    }
+    if ($ && $ + 1 < t.length) {
+      const k = t.slice($ + 1);
+      l.push(k), e.tokens && (i[i.length - 1].value = k, Dt(i[i.length - 1]), q.maxDepth += i[i.length - 1].depth);
+    }
+    q.slashes = n, q.parts = l;
+  }
+  return q;
+};
+var Ws = Gs;
+const rt = pt, U = it, {
+  MAX_LENGTH: ct,
+  POSIX_REGEX_SOURCE: Us,
+  REGEX_NON_SPECIAL_CHARS: qs,
+  REGEX_SPECIAL_CHARS_BACKREF: Ks,
+  REPLACEMENTS: Vt
+} = rt, Xs = (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) => U.escapeRegex(o)).join("..");
+  }
+  return e;
+}, et = (t, s) => `Missing ${t}: "${s}" - use "\\\\${s}" to match literal characters`, Jt = (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;
+}, js = (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;
+}, Ct = (t) => {
+  let s = t.trim(), e = !0;
+  for (; e === !0; )
+    e = !1, /^@\([^\\()[\]{}|]+\)$/.test(s) && (s = s.slice(2, -1), e = !0);
+  if (js(s))
+    return s.replace(/\\(.)/g, "$1");
+}, Qs = (t) => {
+  const s = t.map(Ct).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;
+}, Et = (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
+          };
+      }
+    }
+  }
+}, zs = (t) => `${t.length === 1 ? U.escapeRegex(t[0]) : `[${t.map((e) => U.escapeRegex(e)).join("")}]`}*`, Ys = (t) => {
+  let s = 0;
+  const e = [];
+  for (; s < t.length; ) {
+    const r = Et(t.slice(s), !1);
+    if (!r || r.type !== "*")
+      return;
+    const o = Jt(r.body).map((i) => i.trim());
+    if (o.length !== 1)
+      return;
+    const n = Ct(o[0]);
+    if (!n || n.length !== 1)
+      return;
+    e.push(n), s += r.end + 1;
+  }
+  if (!(e.length < 1))
+    return e;
+}, Zs = (t) => {
+  let s = 0, e = t.trim(), r = Et(e);
+  for (; r; )
+    s++, e = r.body.trim(), r = Et(e);
+  return s;
+}, Vs = (t, s) => {
+  if (s.maxExtglobRecursion === !1)
+    return { risky: !1 };
+  const e = typeof s.maxExtglobRecursion == "number" ? s.maxExtglobRecursion : rt.DEFAULT_MAX_EXTGLOB_RECURSION, r = Jt(t).map((l) => l.trim());
+  if (r.length > 1 && (r.some((l) => l === "") || r.some((l) => /^[*?]+$/.test(l)) || Qs(r)))
+    return { risky: !0 };
+  const o = [];
+  let n = !1, i = !0;
+  for (const l of r) {
+    const h = Ys(l);
+    if (h) {
+      n = !0, o.push(...h);
+      continue;
+    }
+    const g = Ct(l);
+    if (g && g.length === 1) {
+      o.push(g);
+      continue;
+    }
+    if (i = !1, Zs(l) > e)
+      return { risky: !0 };
+  }
+  return n ? i ? { risky: !0, safeOutput: zs([...new Set(o)]) } : { risky: !0 } : { risky: !1 };
+}, $t = (t, s) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected a string");
+  t = Vt[t] || t;
+  const e = { ...s }, r = typeof e.maxLength == "number" ? Math.min(ct, e.maxLength) : ct;
+  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 = rt.globChars(e.windows), g = rt.extglobChars(h), {
+    DOT_LITERAL: d,
+    PLUS_LITERAL: A,
+    SLASH_LITERAL: S,
+    ONE_CHAR: x,
+    DOTS_SLASH: y,
+    NO_DOT: C,
+    NO_DOT_SLASH: T,
+    NO_DOTS_SLASH: G,
+    QMARK: _,
+    QMARK_NO_DOT: M,
+    STAR: X,
+    START_ANCHOR: P
+  } = h, O = (p) => `(${l}(?:(?!${P}${p.dot ? y : d}).)*?)`, v = e.dot ? "" : C, R = e.dot ? _ : M;
+  let m = e.bash === !0 ? O(e) : X;
+  e.capture && (m = `(${m})`), typeof e.noext == "boolean" && (e.noextglob = e.noext);
+  const c = {
+    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 = U.removePrefix(t, c), o = t.length;
+  const W = [], N = [], D = [];
+  let a = n, u;
+  const q = () => c.index === o - 1, $ = c.peek = (p = 1) => t[c.index + p], k = c.advance = () => t[++c.index] || "", Y = () => t.slice(c.index + 1), K = (p = "", L = 0) => {
+    c.consumed += p, c.index += L;
+  }, V = (p) => {
+    c.output += p.output != null ? p.output : p.value, K(p.value);
+  }, le = () => {
+    let p = 1;
+    for (; $() === "!" && ($(2) !== "(" || $(3) === "?"); )
+      k(), c.start++, p++;
+    return p % 2 === 0 ? !1 : (c.negated = !0, c.start++, !0);
+  }, ut = (p) => {
+    c[p]++, D.push(p);
+  }, J = (p) => {
+    c[p]--, D.pop();
+  }, E = (p) => {
+    if (a.type === "globstar") {
+      const L = c.braces > 0 && (p.type === "comma" || p.type === "brace"), f = p.extglob === !0 || W.length && (p.type === "pipe" || p.type === "paren");
+      p.type !== "slash" && p.type !== "paren" && !L && !f && (c.output = c.output.slice(0, -a.output.length), a.type = "star", a.value = "*", a.output = m, c.output += a.output);
+    }
+    if (W.length && p.type !== "paren" && (W[W.length - 1].inner += p.value), (p.value || p.output) && V(p), a && a.type === "text" && p.type === "text") {
+      a.output = (a.output || a.value) + p.value, a.value += p.value;
+      return;
+    }
+    p.prev = a, i.push(p), a = p;
+  }, at = (p, L) => {
+    const f = { ...g[L], conditions: 1, inner: "" };
+    f.prev = a, f.parens = c.parens, f.output = c.output, f.startIndex = c.index, f.tokensIndex = i.length;
+    const b = (e.capture ? "(" : "") + f.open;
+    ut("parens"), E({ type: p, value: L, output: c.output ? "" : x }), E({ type: "paren", extglob: !0, value: k(), output: b }), W.push(f);
+  }, fe = (p) => {
+    const L = t.slice(p.startIndex, c.index + 1), f = t.slice(p.startIndex + 2, c.index), b = Vs(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, j = i[p.tokensIndex];
+      j.type = "text", j.value = L, j.output = w || U.escapeRegex(L);
+      for (let Q = p.tokensIndex + 1; Q < i.length; Q++)
+        i[Q].value = "", i[Q].output = "", delete i[Q].suffix;
+      c.output = p.output + j.output, c.backtrack = !0, E({ type: "paren", extglob: !0, value: u, output: "" }), J("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 || q() || /^\)+$/.test(Y())) && (H = p.close = `)$))${w}`), p.inner.includes("*") && (F = Y()) && /^\.[^\\/.]+$/.test(F)) {
+        const j = $t(F, { ...s, fastpaths: !1 }).output;
+        H = p.close = `)${j})${w})`;
+      }
+      p.prev.type === "bos" && (c.negatedExtglob = !0);
+    }
+    E({ type: "paren", extglob: !0, value: u, output: H }), J("parens");
+  };
+  if (e.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(t)) {
+    let p = !1, L = t.replace(Ks, (f, b, H, F, w, j) => F === "\\" ? (p = !0, f) : F === "?" ? b ? b + F + (w ? _.repeat(w.length) : "") : j === 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 ? (c.output = t, c) : (c.output = U.wrapOutput(L, c, s), c);
+  }
+  for (; !q(); ) {
+    if (u = k(), u === "\0")
+      continue;
+    if (u === "\\") {
+      const f = $();
+      if (f === "/" && e.bash !== !0 || f === "." || f === ";")
+        continue;
+      if (!f) {
+        u += "\\", E({ type: "text", value: u });
+        continue;
+      }
+      const b = /^\\+/.exec(Y());
+      let H = 0;
+      if (b && b[0].length > 2 && (H = b[0].length, c.index += H, H % 2 !== 0 && (u += "\\")), e.unescape === !0 ? u = k() : u += k(), c.brackets === 0) {
+        E({ type: "text", value: u });
+        continue;
+      }
+    }
+    if (c.brackets > 0 && (u !== "]" || a.value === "[" || a.value === "[^")) {
+      if (e.posix !== !1 && u === ":") {
+        const f = a.value.slice(1);
+        if (f.includes("[") && (a.posix = !0, f.includes(":"))) {
+          const b = a.value.lastIndexOf("["), H = a.value.slice(0, b), F = a.value.slice(b + 2), w = Us[F];
+          if (w) {
+            a.value = H + w, c.backtrack = !0, k(), !n.output && i.indexOf(a) === 1 && (n.output = x);
+            continue;
+          }
+        }
+      }
+      (u === "[" && $() !== ":" || u === "-" && $() === "]") && (u = `\\${u}`), u === "]" && (a.value === "[" || a.value === "[^") && (u = `\\${u}`), e.posix === !0 && u === "!" && a.value === "[" && (u = "^"), a.value += u, V({ value: u });
+      continue;
+    }
+    if (c.quotes === 1 && u !== '"') {
+      u = U.escapeRegex(u), a.value += u, V({ value: u });
+      continue;
+    }
+    if (u === '"') {
+      c.quotes = c.quotes === 1 ? 0 : 1, e.keepQuotes === !0 && E({ type: "text", value: u });
+      continue;
+    }
+    if (u === "(") {
+      ut("parens"), E({ type: "paren", value: u });
+      continue;
+    }
+    if (u === ")") {
+      if (c.parens === 0 && e.strictBrackets === !0)
+        throw new SyntaxError(et("opening", "("));
+      const f = W[W.length - 1];
+      if (f && c.parens === f.parens + 1) {
+        fe(W.pop());
+        continue;
+      }
+      E({ type: "paren", value: u, output: c.parens ? ")" : "\\)" }), J("parens");
+      continue;
+    }
+    if (u === "[") {
+      if (e.nobracket === !0 || !Y().includes("]")) {
+        if (e.nobracket !== !0 && e.strictBrackets === !0)
+          throw new SyntaxError(et("closing", "]"));
+        u = `\\${u}`;
+      } else
+        ut("brackets");
+      E({ type: "bracket", value: u });
+      continue;
+    }
+    if (u === "]") {
+      if (e.nobracket === !0 || a && a.type === "bracket" && a.value.length === 1) {
+        E({ type: "text", value: u, output: `\\${u}` });
+        continue;
+      }
+      if (c.brackets === 0) {
+        if (e.strictBrackets === !0)
+          throw new SyntaxError(et("opening", "["));
+        E({ type: "text", value: u, output: `\\${u}` });
+        continue;
+      }
+      J("brackets");
+      const f = a.value.slice(1);
+      if (a.posix !== !0 && f[0] === "^" && !f.includes("/") && (u = `/${u}`), a.value += u, V({ value: u }), e.literalBrackets === !1 || U.hasRegexChars(f))
+        continue;
+      const b = U.escapeRegex(a.value);
+      if (c.output = c.output.slice(0, -a.value.length), e.literalBrackets === !0) {
+        c.output += b, a.value = b;
+        continue;
+      }
+      a.value = `(${l}${b}|${a.value})`, c.output += a.value;
+      continue;
+    }
+    if (u === "{" && e.nobrace !== !0) {
+      ut("braces");
+      const f = {
+        type: "brace",
+        value: u,
+        output: "(",
+        outputIndex: c.output.length,
+        tokensIndex: c.tokens.length
+      };
+      N.push(f), E(f);
+      continue;
+    }
+    if (u === "}") {
+      const f = N[N.length - 1];
+      if (e.nobrace === !0 || !f) {
+        E({ type: "text", value: u, output: u });
+        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 = Xs(F, e), c.backtrack = !0;
+      }
+      if (f.comma !== !0 && f.dots !== !0) {
+        const H = c.output.slice(0, f.outputIndex), F = c.tokens.slice(f.tokensIndex);
+        f.value = f.output = "\\{", u = b = "\\}", c.output = H;
+        for (const w of F)
+          c.output += w.output || w.value;
+      }
+      E({ type: "brace", value: u, output: b }), J("braces"), N.pop();
+      continue;
+    }
+    if (u === "|") {
+      W.length > 0 && W[W.length - 1].conditions++, E({ type: "text", value: u });
+      continue;
+    }
+    if (u === ",") {
+      let f = u;
+      const b = N[N.length - 1];
+      b && D[D.length - 1] === "braces" && (b.comma = !0, f = "|"), E({ type: "comma", value: u, output: f });
+      continue;
+    }
+    if (u === "/") {
+      if (a.type === "dot" && c.index === c.start + 1) {
+        c.start = c.index + 1, c.consumed = "", c.output = "", i.pop(), a = n;
+        continue;
+      }
+      E({ type: "slash", value: u, output: S });
+      continue;
+    }
+    if (u === ".") {
+      if (c.braces > 0 && a.type === "dot") {
+        a.value === "." && (a.output = d);
+        const f = N[N.length - 1];
+        a.type = "dots", a.output += u, a.value += u, f.dots = !0;
+        continue;
+      }
+      if (c.braces + c.parens === 0 && a.type !== "bos" && a.type !== "slash") {
+        E({ type: "text", value: u, output: d });
+        continue;
+      }
+      E({ type: "dot", value: u, output: d });
+      continue;
+    }
+    if (u === "?") {
+      if (!(a && a.value === "(") && e.noextglob !== !0 && $() === "(" && $(2) !== "?") {
+        at("qmark", u);
+        continue;
+      }
+      if (a && a.type === "paren") {
+        const b = $();
+        let H = u;
+        (a.value === "(" && !/[!=<:]/.test(b) || b === "<" && !/<([!=]|\w+>)/.test(Y())) && (H = `\\${u}`), E({ type: "text", value: u, output: H });
+        continue;
+      }
+      if (e.dot !== !0 && (a.type === "slash" || a.type === "bos")) {
+        E({ type: "qmark", value: u, output: M });
+        continue;
+      }
+      E({ type: "qmark", value: u, output: _ });
+      continue;
+    }
+    if (u === "!") {
+      if (e.noextglob !== !0 && $() === "(" && ($(2) !== "?" || !/[!=<:]/.test($(3)))) {
+        at("negate", u);
+        continue;
+      }
+      if (e.nonegate !== !0 && c.index === 0) {
+        le();
+        continue;
+      }
+    }
+    if (u === "+") {
+      if (e.noextglob !== !0 && $() === "(" && $(2) !== "?") {
+        at("plus", u);
+        continue;
+      }
+      if (a && a.value === "(" || e.regex === !1) {
+        E({ type: "plus", value: u, output: A });
+        continue;
+      }
+      if (a && (a.type === "bracket" || a.type === "paren" || a.type === "brace") || c.parens > 0) {
+        E({ type: "plus", value: u });
+        continue;
+      }
+      E({ type: "plus", value: A });
+      continue;
+    }
+    if (u === "@") {
+      if (e.noextglob !== !0 && $() === "(" && $(2) !== "?") {
+        E({ type: "at", extglob: !0, value: u, output: "" });
+        continue;
+      }
+      E({ type: "text", value: u });
+      continue;
+    }
+    if (u !== "*") {
+      (u === "$" || u === "^") && (u = `\\${u}`);
+      const f = qs.exec(Y());
+      f && (u += f[0], c.index += f[0].length), E({ type: "text", value: u });
+      continue;
+    }
+    if (a && (a.type === "globstar" || a.star === !0)) {
+      a.type = "star", a.star = !0, a.value += u, a.output = m, c.backtrack = !0, c.globstar = !0, K(u);
+      continue;
+    }
+    let p = Y();
+    if (e.noextglob !== !0 && /^\([^?]/.test(p)) {
+      at("star", u);
+      continue;
+    }
+    if (a.type === "star") {
+      if (e.noglobstar === !0) {
+        K(u);
+        continue;
+      }
+      const f = a.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] !== "/")) {
+        E({ type: "star", value: u, output: "" });
+        continue;
+      }
+      const w = c.braces > 0 && (f.type === "comma" || f.type === "brace"), j = W.length && (f.type === "pipe" || f.type === "paren");
+      if (!H && f.type !== "paren" && !w && !j) {
+        E({ type: "star", value: u, output: "" });
+        continue;
+      }
+      for (; p.slice(0, 3) === "/**"; ) {
+        const Q = t[c.index + 4];
+        if (Q && Q !== "/")
+          break;
+        p = p.slice(3), K("/**", 3);
+      }
+      if (f.type === "bos" && q()) {
+        a.type = "globstar", a.value += u, a.output = O(e), c.output = a.output, c.globstar = !0, K(u);
+        continue;
+      }
+      if (f.type === "slash" && f.prev.type !== "bos" && !F && q()) {
+        c.output = c.output.slice(0, -(f.output + a.output).length), f.output = `(?:${f.output}`, a.type = "globstar", a.output = O(e) + (e.strictSlashes ? ")" : "|$)"), a.value += u, c.globstar = !0, c.output += f.output + a.output, K(u);
+        continue;
+      }
+      if (f.type === "slash" && f.prev.type !== "bos" && p[0] === "/") {
+        const Q = p[1] !== void 0 ? "|$" : "";
+        c.output = c.output.slice(0, -(f.output + a.output).length), f.output = `(?:${f.output}`, a.type = "globstar", a.output = `${O(e)}${S}|${S}${Q})`, a.value += u, c.output += f.output + a.output, c.globstar = !0, K(u + k()), E({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      if (f.type === "bos" && p[0] === "/") {
+        a.type = "globstar", a.value += u, a.output = `(?:^|${S}|${O(e)}${S})`, c.output = a.output, c.globstar = !0, K(u + k()), E({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      c.output = c.output.slice(0, -a.output.length), a.type = "globstar", a.output = O(e), a.value += u, c.output += a.output, c.globstar = !0, K(u);
+      continue;
+    }
+    const L = { type: "star", value: u, output: m };
+    if (e.bash === !0) {
+      L.output = ".*?", (a.type === "bos" || a.type === "slash") && (L.output = v + L.output), E(L);
+      continue;
+    }
+    if (a && (a.type === "bracket" || a.type === "paren") && e.regex === !0) {
+      L.output = u, E(L);
+      continue;
+    }
+    (c.index === c.start || a.type === "slash" || a.type === "dot") && (a.type === "dot" ? (c.output += T, a.output += T) : e.dot === !0 ? (c.output += G, a.output += G) : (c.output += v, a.output += v), $() !== "*" && (c.output += x, a.output += x)), E(L);
+  }
+  for (; c.brackets > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(et("closing", "]"));
+    c.output = U.escapeLast(c.output, "["), J("brackets");
+  }
+  for (; c.parens > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(et("closing", ")"));
+    c.output = U.escapeLast(c.output, "("), J("parens");
+  }
+  for (; c.braces > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(et("closing", "}"));
+    c.output = U.escapeLast(c.output, "{"), J("braces");
+  }
+  if (e.strictSlashes !== !0 && (a.type === "star" || a.type === "bracket") && E({ type: "maybe_slash", value: "", output: `${S}?` }), c.backtrack === !0) {
+    c.output = "";
+    for (const p of c.tokens)
+      c.output += p.output != null ? p.output : p.value, p.suffix && (c.output += p.suffix);
+  }
+  return c;
+};
+$t.fastpaths = (t, s) => {
+  const e = { ...s }, r = typeof e.maxLength == "number" ? Math.min(ct, e.maxLength) : ct, o = t.length;
+  if (o > r)
+    throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${r}`);
+  t = Vt[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: S,
+    START_ANCHOR: x
+  } = rt.globChars(e.windows), y = e.dot ? d : g, C = e.dot ? A : g, T = e.capture ? "" : "?:", G = { negated: !1, prefix: "" };
+  let _ = e.bash === !0 ? ".*?" : S;
+  e.capture && (_ = `(${_})`);
+  const M = (v) => v.noglobstar === !0 ? _ : `(${T}(?:(?!${x}${v.dot ? h : n}).)*?)`, X = (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 = X(R[1]);
+        return m ? m + n + R[2] : void 0;
+      }
+    }
+  }, P = U.removePrefix(t, G);
+  let O = X(P);
+  return O && e.strictSlashes !== !0 && (O += `${i}?`), O;
+};
+var Js = $t;
+const tn = Ws, bt = Js, te = it, en = pt, sn = (t) => t && typeof t == "object" && !Array.isArray(t), I = (t, s, e = !1) => {
+  if (Array.isArray(t)) {
+    const d = t.map((S) => I(S, s, e));
+    return (S) => {
+      for (const x of d) {
+        const y = x(S);
+        if (y) return y;
+      }
+      return !1;
+    };
+  }
+  const r = sn(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 ? I.compileRe(t, s) : I.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 = I(o.ignore, d, e);
+  }
+  const g = (d, A = !1) => {
+    const { isMatch: S, match: x, output: y } = I.test(d, i, s, { glob: t, posix: n }), C = { glob: t, state: l, regex: i, posix: n, input: d, output: y, match: x, isMatch: S };
+    return typeof o.onResult == "function" && o.onResult(C), S === !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;
+};
+I.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 ? te.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 = I.matchBase(t, s, e, o) : l = s.exec(h)), { isMatch: !!l, match: l, output: h };
+};
+I.matchBase = (t, s, e, r = e && e.windows) => (s instanceof RegExp ? s : I.makeRe(s, e)).test(te.basename(t, { windows: r }));
+I.isMatch = (t, s, e) => I(s, e)(t);
+I.parse = (t, s) => Array.isArray(t) ? t.map((e) => I.parse(e, s)) : bt(t, { ...s, fastpaths: !1 });
+I.scan = (t, s) => tn(t, s);
+I.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 = I.toRegex(l, s);
+  return r === !0 && (h.state = t), h;
+};
+I.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 = bt.fastpaths(t, s)), o.output || (o = bt(t, s)), I.compileRe(o, s, e, r);
+};
+I.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 /$^/;
+  }
+};
+I.constants = en;
+var nn = I;
+const ee = nn, rn = it;
+function se(t, s, e = !1) {
+  return s && (s.windows === null || s.windows === void 0) && (s = { ...s, windows: rn.isWindows() }), ee(t, s, e);
+}
+Object.assign(se, ee);
+var on = se;
+const ot = /* @__PURE__ */ Es(on), un = Array.isArray, ne = /\\/g, an = /^[A-Za-z]:$/, vt = process.platform === "win32", cn = /^(\/?\.\.)+$/;
+function ln(t, s = {}) {
+  const e = t.length, r = Array(e), o = Array(e);
+  let n, i;
+  for (n = 0; n < e; n++) {
+    const l = re(t[n]);
+    r[n] = l;
+    const h = l.length, g = Array(h);
+    for (i = 0; i < h; i++) g[i] = ot(l[i], s);
+    o[n] = g;
+  }
+  return (l) => {
+    const h = l.split("/");
+    if (h[0] === ".." && cn.test(l)) return !0;
+    for (n = 0; n < e; n++) {
+      const g = r[n], d = o[n], A = h.length, S = Math.min(A, g.length);
+      for (i = 0; i < S; ) {
+        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 fn = /^[A-Z]:\/$/i, pn = vt ? (t) => fn.test(t) : (t) => t === "/";
+function It(t, s, e) {
+  if (t === s || s.startsWith(`${t}/`)) {
+    if (e) {
+      const o = t.length + +!pn(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 hn(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 Nt(t) {
+  return t.replace(an, (s) => `${s}/`);
+}
+const gn = { parts: !0 };
+function re(t) {
+  var s;
+  const e = ot.scan(t, gn);
+  return !((s = e.parts) === null || s === void 0) && s.length ? e.parts : [t];
+}
+const yn = /\\(?![()[\]{}!+@])/g;
+function dn(t) {
+  return oe(t);
+}
+function An(t) {
+  return ie(t).replace(yn, "/");
+}
+const Tn = vt ? An : dn, Rn = new RegExp("(?<!\\\\)([()[\\]{}*?|]|^!|[!+@](?=\\()|\\\\(?![()[\\]{}!*+?@|]))", "g"), _n = new RegExp("(?<!\\\\)([()[\\]{}]|^!|[!+@](?=\\())", "g"), oe = (t) => t.replace(Rn, "\\$&"), ie = (t) => t.replace(_n, "\\$&"), Sn = vt ? ie : oe;
+function En(t, s) {
+  if ((s == null ? void 0 : s.caseSensitiveMatch) === !1) return !0;
+  const e = ot.scan(t);
+  return e.isGlob || e.negated;
+}
+function nt(...t) {
+  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...t);
+}
+function ue(t) {
+  return typeof t == "string" ? [t] : t ?? [];
+}
+const bn = /^(\/?\.\.)+/, mn = /\\(?=[()[\]{}!*+?@|])/g;
+function _t(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 = xe(i.replace(mn, "")) ? tt.relative(l, i) : tt.normalize(i);
+  const h = (o = bn.exec(i)) === null || o === void 0 ? void 0 : o[0], g = re(i);
+  if (h) {
+    const A = (h.length + 1) / 3;
+    let S = 0;
+    const x = l.split("/");
+    for (; S < A && g[S + A] === x[x.length + S - A]; )
+      i = i.slice(0, (A - S - 1) * 3) + i.slice((A - S) * 3 + g[S + A].length + 1) || ".", S++;
+    const y = tt.join(n, h.slice(S * 3));
+    y[0] !== "." && e.root.length > y.length && (e.root = Nt(y), e.depthOffset = -A + S);
+  }
+  if (!r && e.depthOffset >= 0) {
+    var d;
+    (d = e.commonPath) !== null && d !== void 0 || (e.commonPath = g);
+    const A = [], S = Math.min(e.commonPath.length, g.length);
+    for (let x = 0; x < S; x++) {
+      const y = g[x];
+      if (y === "**" && !g[x + 1]) {
+        A.pop();
+        break;
+      }
+      if (x === g.length - 1 || y !== e.commonPath[x] || En(y)) break;
+      A.push(y);
+    }
+    e.depthOffset = A.length, e.commonPath = A, e.root = Nt(A.length > 0 ? tt.join(n, ...A) : n);
+  }
+  return i;
+}
+function xn(t, s, e) {
+  const r = [], o = [];
+  for (const n of t.ignore)
+    n && (n[0] !== "!" || n[1] === "(") && o.push(_t(n, t, e, !0));
+  for (const n of s)
+    n && (n[0] !== "!" || n[1] === "(" ? r.push(_t(n, t, e, !1)) : (n[1] !== "!" || n[2] === "(") && o.push(_t(n.slice(1), t, e, !0)));
+  return {
+    match: r,
+    ignore: o
+  };
+}
+function Cn(t, s) {
+  const e = t.cwd, r = {
+    root: e,
+    depthOffset: 0
+  }, o = xn(t, s, r);
+  t.debug && nt("internal processing patterns:", o);
+  const { absolute: n, caseSensitiveMatch: i, debug: l, dot: h, followSymbolicLinks: g, onlyDirectories: d } = t, A = r.root.replace(ne, ""), S = {
+    dot: h,
+    nobrace: t.braceExpansion === !1,
+    nocase: !i,
+    noextglob: t.extglob === !1,
+    noglobstar: t.globstar === !1,
+    posix: !0
+  }, x = ot(o.match, S), y = ot(o.ignore, S), C = ln(o.match, S), T = It(e, A, n), G = n ? T : It(e, A, !0), _ = (P, O) => {
+    const v = G(O, !0);
+    return v !== "." && !C(v) || y(v);
+  };
+  let M;
+  t.deep !== void 0 && (M = Math.round(t.deep - r.depthOffset));
+  const X = new Ss({
+    filters: [l ? (P, O) => {
+      const v = T(P, O), R = x(v) && !y(v);
+      return R && nt(`matched ${v}`), R;
+    } : (P, O) => {
+      const v = T(P, O);
+      return x(v) && !y(v);
+    }],
+    exclude: l ? (P, O) => {
+      const v = _(P, O);
+      return nt(`${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 && nt("internal properties:", {
+    ...r,
+    root: A
+  }), [X, e !== A && !n && hn(e, A)];
+}
+function ae(t, s) {
+  if (s) for (let e = t.length - 1; e >= 0; e--) t[e] = s(t[e]);
+  return t;
+}
+const Bt = {
+  caseSensitiveMatch: !0,
+  debug: !!process.env.TINYGLOBBY_DEBUG,
+  expandDirectories: !0,
+  followSymbolicLinks: !0,
+  onlyFiles: !0
+};
+function $n(t) {
+  const s = Object.assign({}, t);
+  for (const e in Bt) s[e] === void 0 && Object.assign(s, { [e]: Bt[e] });
+  return s.cwd = (s.cwd instanceof URL ? Ce(s.cwd) : Mt(s.cwd || process.cwd())).replace(ne, "/"), s.ignore = ue(s.ignore), s.fs && (s.fs = {
+    readdir: s.fs.readdir || Se,
+    readdirSync: s.fs.readdirSync || _e,
+    realpath: s.fs.realpath || Re,
+    realpathSync: s.fs.realpathSync || Ae,
+    stat: s.fs.stat || de,
+    statSync: s.fs.statSync || ye
+  }), s.debug && nt("globbing with options:", s), s;
+}
+function ce(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 = un(t) || typeof t == "string", o = ue((e = r ? t : t.patterns) !== null && e !== void 0 ? e : "**/*"), n = $n(r ? s : t);
+  return o.length > 0 ? Cn(n, o) : [];
+}
+async function kn(t, s) {
+  const [e, r] = ce(t, s);
+  return e ? ae(await e.withPromise(), r) : [];
+}
+function Pn(t, s) {
+  const [e, r] = ce(t, s);
+  return e ? ae(e.sync(), r) : [];
+}
+export {
+  Tn as convertPathToPattern,
+  Sn as escapePath,
+  kn as glob,
+  Pn as globSync,
+  En as isDynamicPattern
+};